ggconfig

type Config struct {
	// Gen configures gg gen behavior.
	Gen GenConfig `yaml:"gen"`

	// Prune configures gg prune, and gg gen --prune, which prunes the same
	// way.
	Prune PruneConfig `yaml:"prune"`
}

type GenConfig struct {
	// Routes configures route generation behavior.
	Routes GenRoutesConfig `yaml:"routes"`

	// Models configures model registration generation behavior.
	Models GenModelsConfig `yaml:"models"`
}

type GenModelsConfig struct {
	// Ignore lists models excluded from the generated model.Register calls.
	// A matched model keeps its routes, services, and generated files; only
	// its registration (and with it table creation) disappears.
	Ignore ModelIgnoreRules `yaml:"ignore"`
}

type GenRoutesConfig struct {
	// Ignore maps route paths to the HTTP methods excluded from code
	// generation. A matched action drops out of the generated registration
	// files while its service file stays on disk.
	Ignore RouteIgnoreRules `yaml:"ignore"`
}

type ModelIgnoreRules []ModelRule

type ModelRule struct {
	// Name is the Go struct name of the model, e.g. "Profile".
	Name string

	// From restricts the rule to models whose file path lives under this
	// directory prefix (e.g. "model/iam"). Empty means the rule applies to
	// every model with a matching name. It protects a project's own model
	// of the same name declared elsewhere.
	From string

	// Raw preserves the original entry for error and log output.
	Raw string
}

type PruneConfig struct {
	// Ignore lists the paths gg prune never deletes, whatever the reason it
	// would: a disabled action's service file, a file in an orphan service
	// directory, a directory left empty, the middleware or interceptor of a
	// removed copied module, or a protobuf definition gg gen would not write
	// now. Of the ignore rules it is the only one that keeps a path from gg
	// prune: the project's Git ignore rules and the go command's ignores
	// protect nothing, and only decide, as they do for gg check and gg gen,
	// which code counts as still using a service directory. Each entry is a
	// path under service/, middleware/, interceptor/ or pb/, relative to the
	// project root, and matches by directory level, the way the from field of
	// an ignore rule does: "service/iam" covers service/iam and everything
	// below it but not service/iamx, and "service/record/list.go" covers that
	// one file. Under pb/ an entry keeps the definitions alone: the Go files
	// there are derived from the models and rewritten by every gg gen, so
	// "pb/legacy" leaves them to be deleted and an entry naming one is
	// rejected. Entries are plain paths: no wildcards, no regular expressions.
	Ignore []string `yaml:"ignore"`
}

type RouteIgnoreRules []RouteRule

type RouteRule struct {
	// Method is the upper-cased HTTP method.
	Method string

	// Segments is the normalized route path split into segments. Parameter
	// segments keep their ":name" form but match positionally by shape.
	Segments []string

	// Raw preserves the original entry for error and log output.
	Raw string

	// From restricts the rule to actions declared by models whose file path
	// lives under this directory prefix (e.g. "model/iam"). Empty means the
	// rule applies to every model declaring a matching route. It lets a
	// project ignore a framework module's route while re-declaring the same
	// route in its own model directory.
	From string
}