Function generateRbacObjects

scripts/typegen/main.go:203–300

generateRbacObjects will take the policy.go file, and send it as input to the go templates. Some AST of the Action enum is also included.

(templateSource string)

// generateRbacObjects will take the policy.go file, and send it as input
// to the go templates. Some AST of the Action enum is also included.
func generateRbacObjects(templateSource string) ([]byte, error) {
	// Parse the policy.go file for the action enums
	f, err := parser.ParseFile(token.NewFileSet(), "./coderd/rbac/policy/policy.go", nil, parser.ParseComments)
	if err != nil {
		return nil, xerrors.Errorf("parsing policy.go: %w", err)
	}
	actionMap := fileActions(f)
	actionList := make([]ActionDetails, 0)
	for value, enum := range actionMap {
		actionList = append(actionList, ActionDetails{
			Enum:  enum,
			Value: value,
		})
	}

	// Sorting actions for auto gen consistency.
	slices.SortFunc(actionList, func(a, b ActionDetails) int {
		return strings.Compare(a.Enum, b.Enum)
	})

	var errorList []error
	var x int
	tpl, err := template.New("object.gotmpl").Funcs(template.FuncMap{
		"capitalize":     utilstrings.Capitalize,
		"pascalCaseName": pascalCaseName[string],
		"actionsList": func() []ActionDetails {
			return actionList
		},
		"actionsOf": func(d Definition) []string {
			// Extract and sort action string keys for deterministic output.
			list := make([]string, 0, len(d.Actions))
			for a := range d.Actions {
				list = append(list, string(a))
			}
			slices.Sort(list)
			return list
		},
		"allCaseList": func(defs []Definition) string {
			// Build a multi-line comma-separated list of all scope constants (including builtins)
			// suitable for use in a `case ...:` clause, without a trailing comma.
			var names []string
			// Builtins first, sourced dynamically from the rbac package to avoid drift.
			for _, n := range rbac.BuiltinScopeNames() {
				// Use typed string literals to avoid relying on constant identifiers.
				names = append(names, fmt.Sprintf("ScopeName(%q)", string(n)))
			}
			for _, d := range defs {
				res := pascalCaseName[string](d.Type)
				acts := make([]string, 0, len(d.Actions))
				for a := range d.Actions {
					acts = append(acts, string(a))
				}
				slices.Sort(acts)
				for _, a := range acts {
					names = append(names, "Scope"+res+pascalCaseName[string](a))
				}
			}
			return strings.Join(names, ",\n\t\t")