@soapjs/cli 1.0.0

package/build/commands/add/add.command.js

@@ -0,0 +1,709 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAddCommand = void 0;
+const command_context_1 = require("../../core/command-context");
+const errors_1 = require("../../core/errors");
+const load_soap_config_1 = require("../../config/load-soap-config");
+const write_soap_config_1 = require("../../config/write-soap-config");
+const file_writer_1 = require("../../io/file-writer");
+const naming_1 = require("../../templates/naming");
+const auth_policy_1 = require("../../config/auth-policy");
+const bruno_plan_1 = require("../generate/bruno-plan");
+const command_plan_1 = require("./command-plan");
+const entity_plan_1 = require("./entity-plan");
+const event_plan_1 = require("./event-plan");
+const query_plan_1 = require("./query-plan");
+const repository_plan_1 = require("./repository-plan");
+const resource_plan_1 = require("./resource-plan");
+const route_plan_1 = require("./route-plan");
+const socket_plan_1 = require("./socket-plan");
+const use_case_plan_1 = require("./use-case-plan");
+const common_options_1 = require("../shared/common-options");
+const add_resource_resolver_1 = require("../../resolvers/add-resource.resolver");
+const add_route_resolver_1 = require("../../resolvers/add-route.resolver");
+const prompts_1 = require("../../prompts");
+function registerAddCommand(program) {
+    const add = program.command("add").description("Add resources, routes, and project components.");
+    (0, common_options_1.addConflictOption)((0, common_options_1.addInteractiveOption)(add
+        .command("resource <name>")
+        .description("Add a resource to an existing SoapJS project.")
+        .option("--crud", "generate CRUD route placeholders", false)
+        .option("--db <database>", "resource storage target: none, mongo, postgres, mysql, sqlite, redis")
+        .option("--auth <auth>", "resource auth strategy: none, jwt, api-key, local")
+        .option("--zone <zone>", "API zone: public, private, admin", "public")
+        .option("--policy <policy>", "auth policy: admin, roles:a,b, custom:name, none")
+        .option("--field <field>", "resource field metadata as name:type or name:type:optional", collect, [])
+        .option("--crud-route <route>", "CRUD route override as operation:method:path[:auth][:zone][:bruno|no-bruno]", collect, [])
+        .option("--dry-run", "print the expanded resource plan without writing files", false)
+        .option("--bruno", "generate Bruno requests when Bruno is enabled", false)
+        .option("--enable-bruno", "enable Bruno API client before adding the resource", false)
+        .option("--yes", "run the expanded resource plan without prompting", false)
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)))
+        .action(async (name, options, command) => {
+        (0, common_options_1.assertInteractiveTerminal)(options);
+        const rootContext = (0, command_context_1.getCommandContext)(command);
+        const context = { ...rootContext, dryRun: rootContext.dryRun || Boolean(options.dryRun) };
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const names = (0, naming_1.createNameVariants)(name);
+        if (config.registry.resources.some((resource) => resource.name === names.kebabName)) {
+            throw new errors_1.CliError(`Resource "${names.kebabName}" already exists.`);
+        }
+        const prompt = options.interactive ? new prompts_1.InquirerPromptAdapter() : undefined;
+        const promptAnswers = prompt
+            ? await (0, prompts_1.promptAddResource)(prompt, {
+                config,
+                provided: createProvidedAddResourceOptions(command),
+            })
+            : undefined;
+        if (options.enableBruno || promptAnswers?.enableBruno) {
+            enableBruno(config);
+        }
+        const resolved = add_resource_resolver_1.addResourceResolver.resolve({
+            flags: createExplicitAddResourceFlags(options, command),
+            promptAnswers,
+            projectConfig: config,
+        });
+        const crudRoutes = (0, resource_plan_1.parseCrudRouteMatrix)(options.crudRoute);
+        const policy = (0, auth_policy_1.parseAuthPolicy)(options.policy);
+        assertAuthPolicyAllowed(policy, resolved.auth);
+        assertCrudRouteMatrixCapabilities(crudRoutes, resolved.auth, config.project.capabilities.auth, config.project.zones);
+        const resourcePlan = {
+            name,
+            crud: resolved.crud,
+            db: resolved.db,
+            auth: resolved.auth,
+            zone: resolved.zone,
+            featuresRoot: config.structure.featuresRoot,
+            architecture: config.project.architecture,
+            contracts: config.project.capabilities.contracts.includes("zod") ? "zod" : "plain",
+            fields: (0, resource_plan_1.parseResourceFieldDefinitions)(options.field),
+            crudRoutes,
+            policy,
+        };
+        const planningSummary = (0, resource_plan_1.createResourceAddPlanningSummary)({
+            ...resourcePlan,
+            architecture: config.project.architecture,
+        });
+        if (context.dryRun || promptAnswers?.dryRunFirst) {
+            context.output.info((0, resource_plan_1.formatResourceAddPlanningSummary)(planningSummary));
+            context.output.success(`Planned resource ${names.kebabName} at /${names.pluralName}`);
+            return;
+        }
+        if (options.interactive) {
+            context.output.info((0, resource_plan_1.formatResourceAddPlanningSummary)(planningSummary));
+            if (!options.yes) {
+                const confirmed = await prompt.confirm({
+                    message: "Add resource?",
+                    defaultValue: true,
+                });
+                if (!confirmed) {
+                    context.output.warn("Resource generation aborted.");
+                    return;
+                }
+            }
+        }
+        const resource = (0, resource_plan_1.createResourceEntry)({
+            ...resourcePlan,
+        });
+        config.registry.resources.push(resource);
+        config.registry.routes.push(...createRouteEntries(resource, resolved.auth, resolved.zone, crudRoutes));
+        const generatedPaths = config.registry.generatedFiles.map((file) => file.path);
+        const existingRouteControllerIndexes = routeControllerIndexResources(generatedPaths, config.structure.featuresRoot, "");
+        const usesCrudControllerIndex = resolved.crud;
+        const routeControllerIndexes = usesCrudControllerIndex
+            ? [...existingRouteControllerIndexes, resource.name]
+            : existingRouteControllerIndexes;
+        const mainControllerResources = config.registry.resources
+            .filter((entry) => !routeControllerIndexes.includes(entry.name))
+            .map((entry) => entry.name);
+        const cqrsConfigFile = config.project.architecture === "cqrs" && resolved.crud
+            ? (0, command_plan_1.createCqrsConfigFile)(config.structure.featuresRoot, {
+                commands: [
+                    ...config.registry.generatedFiles
+                        .map((file) => (0, command_plan_1.commandFeatureFromPath)(file.path, config.structure.featuresRoot))
+                        .filter((feature) => Boolean(feature)),
+                    resource.name,
+                ],
+                queries: [
+                    ...config.registry.generatedFiles
+                        .map((file) => (0, query_plan_1.queryFeatureFromPath)(file.path, config.structure.featuresRoot))
+                        .filter((feature) => Boolean(feature)),
+                    resource.name,
+                ],
+            })
+            : undefined;
+        const brunoEnabled = config.project.capabilities.apiClient.includes("bruno") || config.api.bruno.enabled;
+        const shouldGenerateBruno = options.bruno || promptAnswers?.bruno || (brunoEnabled && !options.interactive);
+        const brunoFiles = shouldGenerateBruno
+            ? (0, bruno_plan_1.createBrunoFiles)(config)
+            : [];
+        const files = [
+            ...(0, resource_plan_1.createResourceFiles)(resourcePlan),
+            (0, resource_plan_1.createResourcesFile)(config.registry.resources, config.structure.featuresRoot),
+            (0, resource_plan_1.createFeaturesIndexFile)(config.registry.resources, config.project.capabilities.auth),
+            (0, resource_plan_1.createControllersFile)(config.registry.resources, config.structure.featuresRoot, config.project.capabilities.auth, routeControllerIndexes, mainControllerResources),
+            ...(cqrsConfigFile ? [cqrsConfigFile] : []),
+            ...brunoFiles,
+        ];
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files,
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+            onConflict: options.onConflict,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Added resource ${names.kebabName} at ${resource.path}`);
+    });
+    (0, common_options_1.addConflictOption)((0, common_options_1.addInteractiveOption)(add
+        .command("route [resource] [name]")
+        .description("Add a route to an existing SoapJS project.")
+        .option("--method <method>", "HTTP method: get, post, put, patch, delete, head, options", "get")
+        .option("--path <path>", "absolute path under the resource path, or relative path segment")
+        .option("--use-case <useCase>", "application use case to call from this route")
+        .option("--command <command>", "CQRS command to dispatch from this route")
+        .option("--query <query>", "CQRS query to dispatch from this route")
+        .option("--auth <auth>", "route auth strategy: none, jwt, api-key, local")
+        .option("--zone <zone>", "API zone: public, private, admin")
+        .option("--policy <policy>", "auth policy: admin, roles:a,b, custom:name, none")
+        .option("--bruno", "generate Bruno requests when Bruno is enabled", false)
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)))
+        .action(async (resourceName, name, options, command) => {
+        (0, common_options_1.assertInteractiveTerminal)(options);
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        if (!options.interactive && (!resourceName || !name)) {
+            throw new errors_1.CliError("Resource and route name are required. Use `soap add route <resource> <name>`.");
+        }
+        if (options.interactive && config.registry.resources.length === 0) {
+            throw new errors_1.CliError("No resources found. Run `soap add resource <name>` first.");
+        }
+        const initialResourceNames = resourceName ? (0, naming_1.createNameVariants)(resourceName) : undefined;
+        const initialResource = initialResourceNames
+            ? config.registry.resources.find((entry) => entry.name === initialResourceNames.kebabName)
+            : undefined;
+        if (resourceName && !initialResource) {
+            throw new errors_1.CliError(`Resource "${initialResourceNames.kebabName}" does not exist. Run \`soap add resource ${initialResourceNames.kebabName}\` first.`);
+        }
+        const prompt = options.interactive ? new prompts_1.InquirerPromptAdapter() : undefined;
+        const promptAnswers = prompt
+            ? await (0, prompts_1.promptAddRoute)(prompt, {
+                config,
+                resource: initialResource,
+                resourceName,
+                routeName: name,
+                provided: createProvidedAddRouteOptions(command, Boolean(resourceName), Boolean(name)),
+            })
+            : undefined;
+        const resolvedResourceName = promptAnswers?.resourceName ?? initialResource.name;
+        const resolvedName = promptAnswers?.name ?? name;
+        const resourceNames = (0, naming_1.createNameVariants)(resolvedResourceName);
+        const routeNames = (0, naming_1.createNameVariants)(resolvedName);
+        const resource = config.registry.resources.find((entry) => entry.name === resourceNames.kebabName);
+        if (!resource) {
+            throw new errors_1.CliError(`Resource "${resourceNames.kebabName}" does not exist. Run \`soap add resource ${resourceNames.kebabName}\` first.`);
+        }
+        if (config.registry.routes.some((route) => route.resource === resource.name && route.name === routeNames.kebabName)) {
+            throw new errors_1.CliError(`Route "${routeNames.kebabName}" already exists on resource "${resource.name}".`);
+        }
+        const resolved = add_route_resolver_1.addRouteResolver.resolve({
+            flags: createExplicitAddRouteFlags(options, command),
+            promptAnswers,
+            projectConfig: { project: config, resource },
+        });
+        const policy = (0, auth_policy_1.parseAuthPolicy)(options.policy);
+        assertAuthPolicyAllowed(policy, resolved.auth);
+        const route = (0, route_plan_1.createRouteEntry)({
+            resource,
+            name: resolvedName,
+            method: resolved.method,
+            path: resolved.path,
+            useCase: resolved.useCase,
+            command: resolved.command,
+            query: resolved.query,
+            auth: resolved.auth,
+            zone: resolved.zone,
+            policy,
+            featuresRoot: config.structure.featuresRoot,
+            contracts: config.project.capabilities.contracts.includes("zod") ? "zod" : "plain",
+        });
+        config.registry.routes.push(route);
+        const routePlan = {
+            resource,
+            name: resolvedName,
+            method: resolved.method,
+            path: resolved.path,
+            useCase: resolved.useCase,
+            command: resolved.command,
+            query: resolved.query,
+            auth: resolved.auth,
+            zone: resolved.zone,
+            policy,
+            featuresRoot: config.structure.featuresRoot,
+            contracts: config.project.capabilities.contracts.includes("zod") ? "zod" : "plain",
+        };
+        const controllerFile = (0, route_plan_1.createRouteControllerFile)(routePlan);
+        const contractFile = (0, route_plan_1.createRouteContractFile)(routePlan);
+        const routeControllerNames = routeControllerNamesForResource(config.registry.generatedFiles.map((file) => file.path), config.structure.featuresRoot, resource.name, controllerFile.path);
+        const routeControllerIndex = (0, route_plan_1.createRouteControllersIndexFile)(resource, config.structure.featuresRoot, routeControllerNames);
+        const controllerIndexes = routeControllerIndexResources(config.registry.generatedFiles.map((file) => file.path), config.structure.featuresRoot, resource.name);
+        const controllersFile = (0, resource_plan_1.createControllersFile)(config.registry.resources, config.structure.featuresRoot, config.project.capabilities.auth, controllerIndexes);
+        const brunoEnabled = config.project.capabilities.apiClient.includes("bruno") || config.api.bruno.enabled;
+        const brunoFiles = options.bruno || promptAnswers?.bruno
+            ? (0, bruno_plan_1.createBrunoFiles)(config)
+            : [];
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files: [
+                controllerFile,
+                contractFile,
+                routeControllerIndex,
+                controllersFile,
+                ...(brunoEnabled ? brunoFiles : []),
+            ],
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+            onConflict: options.onConflict,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Added route ${route.method} ${route.path}`);
+    });
+    add
+        .command("repository <name>")
+        .description("Add a repository port and database adapter to a feature.")
+        .requiredOption("--feature <feature>", "feature that owns the repository")
+        .requiredOption("--db <database>", "database adapter: mongo, postgres, mysql, sqlite")
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)
+        .action(async (name, options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const names = (0, naming_1.createNameVariants)(name);
+        const db = normalizeRepositoryDb(options.db);
+        assertCapability("database", db, config.project.capabilities.databases);
+        const files = (0, repository_plan_1.createRepositoryFiles)({
+            name,
+            feature: options.feature,
+            db,
+            featuresRoot: config.structure.featuresRoot,
+        });
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files,
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Added ${db} repository ${names.kebabName}`);
+    });
+    add
+        .command("entity <name>")
+        .description("Add a domain entity to a feature.")
+        .requiredOption("--feature <feature>", "feature that owns the entity")
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)
+        .action(async (name, options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const names = (0, naming_1.createNameVariants)(name);
+        const files = (0, entity_plan_1.createEntityFiles)({
+            name,
+            feature: options.feature,
+            featuresRoot: config.structure.featuresRoot,
+        });
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files,
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Added entity ${names.kebabName}`);
+    });
+    add
+        .command("use-case <name>")
+        .description("Add an application use case to a feature.")
+        .requiredOption("--feature <feature>", "feature that owns the use case")
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)
+        .action(async (name, options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const names = (0, naming_1.createNameVariants)(name);
+        const files = (0, use_case_plan_1.createUseCaseFiles)({
+            name,
+            feature: options.feature,
+            featuresRoot: config.structure.featuresRoot,
+        });
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files,
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Added use case ${names.kebabName}`);
+    });
+    add
+        .command("command <name>")
+        .description("Add a CQRS command and command handler to a feature.")
+        .requiredOption("--feature <feature>", "feature that owns the command")
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)
+        .action(async (name, options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const names = (0, naming_1.createNameVariants)(name);
+        const feature = (0, naming_1.createNameVariants)(options.feature).kebabName;
+        if (config.project.architecture !== "cqrs") {
+            throw new errors_1.CliError("CQRS commands require a project created with `--architecture cqrs`.");
+        }
+        const commandFiles = (0, command_plan_1.createCommandFiles)({
+            name,
+            feature,
+            featuresRoot: config.structure.featuresRoot,
+        });
+        const commandNames = commandNamesForFeature(config.registry.generatedFiles.map((file) => file.path), config.structure.featuresRoot, feature, names.kebabName);
+        const commandIndex = (0, command_plan_1.createCommandIndexFile)(feature, config.structure.featuresRoot, commandNames);
+        const cqrsFeatures = commandFeatures(config.registry.generatedFiles.map((file) => file.path), config.structure.featuresRoot, feature);
+        const cqrsConfig = (0, command_plan_1.createCqrsConfigFile)(config.structure.featuresRoot, {
+            commands: cqrsFeatures,
+            queries: queryFeatures(config.registry.generatedFiles.map((file) => file.path), config.structure.featuresRoot),
+        });
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files: [...commandFiles, commandIndex, cqrsConfig],
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Added command ${names.kebabName}`);
+    });
+    add
+        .command("query <name>")
+        .description("Add a CQRS query and query handler to a feature.")
+        .requiredOption("--feature <feature>", "feature that owns the query")
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)
+        .action(async (name, options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const names = (0, naming_1.createNameVariants)(name);
+        const feature = (0, naming_1.createNameVariants)(options.feature).kebabName;
+        if (config.project.architecture !== "cqrs") {
+            throw new errors_1.CliError("CQRS queries require a project created with `--architecture cqrs`.");
+        }
+        const queryFiles = (0, query_plan_1.createQueryFiles)({
+            name,
+            feature,
+            featuresRoot: config.structure.featuresRoot,
+        });
+        const queryNames = queryNamesForFeature(config.registry.generatedFiles.map((file) => file.path), config.structure.featuresRoot, feature, names.kebabName);
+        const queryIndex = (0, query_plan_1.createQueryIndexFile)(feature, config.structure.featuresRoot, queryNames);
+        const cqrsConfig = (0, command_plan_1.createCqrsConfigFile)(config.structure.featuresRoot, {
+            commands: commandFeatures(config.registry.generatedFiles.map((file) => file.path), config.structure.featuresRoot),
+            queries: queryFeatures(config.registry.generatedFiles.map((file) => file.path), config.structure.featuresRoot, feature),
+        });
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files: [...queryFiles, queryIndex, cqrsConfig],
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Added query ${names.kebabName}`);
+    });
+    add
+        .command("event <name>")
+        .description("Add a domain event to a feature.")
+        .requiredOption("--feature <feature>", "feature that owns the event")
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)
+        .action(async (name, options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        if (config.project.capabilities.messaging.length === 0) {
+            throw new errors_1.CliError("Messaging is not enabled for this project.");
+        }
+        const files = (0, event_plan_1.createEventFiles)({
+            name,
+            feature: options.feature,
+            architecture: config.project.architecture,
+            featuresRoot: config.structure.featuresRoot,
+        });
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files,
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Added event ${(0, naming_1.createNameVariants)(name).kebabName}`);
+    });
+    add
+        .command("socket <name>")
+        .description("Add a WebSocket message handler to a feature.")
+        .requiredOption("--feature <feature>", "feature that owns the socket handler")
+        .option("--auth <auth>", "socket auth strategy placeholder: none, jwt, api-key, local", "none")
+        .option("--force", "overwrite generated files even when modified", false)
+        .option("--write-new", "write modified generated files as .new", false)
+        .action(async (name, options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        if (!config.project.capabilities.realtime.includes("ws")) {
+            throw new errors_1.CliError("WebSocket support is not enabled. Create the project with `--realtime ws` first.");
+        }
+        const auth = normalizeRouteAuth(options.auth ?? "none");
+        assertCapability("auth", auth, enabledRouteAuthValues(config.project.capabilities.auth));
+        const files = await (0, socket_plan_1.createSocketFiles)(config.root, {
+            name,
+            feature: options.feature,
+            auth,
+            featuresRoot: config.structure.featuresRoot,
+        });
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files,
+            registry: config.registry,
+            force: options.force,
+            writeNew: options.writeNew,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Added socket ${(0, naming_1.createNameVariants)(name).kebabName}`);
+    });
+}
+exports.registerAddCommand = registerAddCommand;
+function firstOrNone(values) {
+    return values[0] ?? "none";
+}
+function firstAuthForRoutes(values) {
+    if (values.includes("jwt") || values.includes("local")) {
+        return "jwt";
+    }
+    return values[0] ?? "none";
+}
+function normalizeRouteAuth(value) {
+    if (value === "local") {
+        return "jwt";
+    }
+    if (value === "jwt" || value === "api-key" || value === "none") {
+        return value;
+    }
+    throw new errors_1.CliError(`Auth "${value}" cannot protect routes. Use jwt, api-key, or none.`);
+}
+function normalizeRepositoryDb(value) {
+    if (value === "mongo" || value === "postgres" || value === "mysql" || value === "sqlite") {
+        return value;
+    }
+    throw new errors_1.CliError("Repository database must be mongo, postgres, mysql, or sqlite.");
+}
+function enabledRouteAuthValues(values) {
+    const allowed = ["none"];
+    if (values.includes("jwt") || values.includes("local")) {
+        allowed.push("jwt");
+    }
+    if (values.includes("api-key")) {
+        allowed.push("api-key");
+    }
+    return allowed;
+}
+function assertCapability(label, value, allowed) {
+    if (!allowed.includes(value)) {
+        const allowedValues = allowed.length > 0 ? allowed.join(", ") : "none";
+        throw new errors_1.CliError(`${label} "${value}" is not enabled for this project. Allowed values: ${allowedValues}.`);
+    }
+}
+function createRouteEntries(resource, auth, zone, matrix = {}) {
+    const now = new Date().toISOString();
+    const routes = [
+        ["list", "GET", resource.path],
+        ["get", "GET", `${resource.path}/:id`],
+    ];
+    if (resource.crud) {
+        routes.push(["create", "POST", resource.path], ["update", "PUT", `${resource.path}/:id`], ["delete", "DELETE", `${resource.path}/:id`]);
+    }
+    return routes.map(([name, defaultMethod, defaultPath]) => {
+        const override = matrix[name];
+        return {
+            resource: resource.name,
+            name,
+            method: (override?.method ?? defaultMethod).toUpperCase(),
+            path: resolveCrudRoutePath(resource.path, override?.path ?? defaultPath),
+            auth: normalizeRouteAuth(override?.auth ?? auth),
+            zone: override?.zone ?? zone,
+            policy: override?.policy ?? resource.policy,
+            bruno: override?.bruno ?? true,
+            generatedAt: now,
+        };
+    });
+}
+function assertCrudRouteMatrixCapabilities(matrix, defaultAuth, authCapabilities, zones) {
+    for (const config of Object.values(matrix)) {
+        if (!config) {
+            continue;
+        }
+        const routeAuth = normalizeRouteAuth(config.auth ?? defaultAuth);
+        assertCapability("auth", routeAuth, enabledRouteAuthValues(authCapabilities));
+        assertAuthPolicyAllowed(config.policy, routeAuth);
+        if (config.zone) {
+            assertCapability("zone", config.zone, zones);
+        }
+    }
+}
+function assertAuthPolicyAllowed(policy, auth) {
+    if (!policy) {
+        return;
+    }
+    if (normalizeRouteAuth(auth) === "none") {
+        throw new errors_1.CliError("Auth policy requires route auth. Use --auth jwt or --auth api-key.");
+    }
+}
+function resolveCrudRoutePath(resourcePath, routePath) {
+    if (routePath === resourcePath || routePath.startsWith(`${resourcePath}/`)) {
+        return routePath;
+    }
+    if (routePath === "/") {
+        return resourcePath;
+    }
+    return `${resourcePath}${routePath.startsWith("/") ? routePath : `/${routePath}`}`;
+}
+function normalizeRouteMethod(value) {
+    const method = value.toLowerCase();
+    if (!route_plan_1.routeMethods.includes(method)) {
+        throw new errors_1.CliError(`Unsupported HTTP method "${value}". Allowed values: ${route_plan_1.routeMethods.join(", ")}.`);
+    }
+    return method;
+}
+function assertSingleRouteTarget(options) {
+    const targets = [options.useCase, options.command, options.query].filter(Boolean);
+    if (targets.length > 1) {
+        throw new errors_1.CliError("Route target options are mutually exclusive. Use only one of --use-case, --command, or --query.");
+    }
+}
+function createProvidedAddResourceOptions(command) {
+    return {
+        crud: isCliOption(command, "crud"),
+        db: isCliOption(command, "db"),
+        auth: isCliOption(command, "auth"),
+        zone: isCliOption(command, "zone"),
+        bruno: isCliOption(command, "bruno"),
+        enableBruno: isCliOption(command, "enableBruno"),
+        dryRunFirst: isCliOption(command, "dryRun"),
+    };
+}
+function createExplicitAddResourceFlags(options, command) {
+    return {
+        crud: isCliOption(command, "crud") ? options.crud : undefined,
+        db: isCliOption(command, "db") ? options.db : undefined,
+        auth: isCliOption(command, "auth") ? options.auth : undefined,
+        zone: isCliOption(command, "zone") ? options.zone : undefined,
+    };
+}
+function createProvidedAddRouteOptions(command, hasResourceName, hasRouteName) {
+    return {
+        resourceName: hasResourceName,
+        name: hasRouteName,
+        method: isCliOption(command, "method"),
+        path: isCliOption(command, "path"),
+        useCase: isCliOption(command, "useCase"),
+        command: isCliOption(command, "command"),
+        query: isCliOption(command, "query"),
+        auth: isCliOption(command, "auth"),
+        zone: isCliOption(command, "zone"),
+        bruno: isCliOption(command, "bruno"),
+    };
+}
+function createExplicitAddRouteFlags(options, command) {
+    return {
+        method: isCliOption(command, "method") ? options.method : undefined,
+        path: isCliOption(command, "path") ? options.path : undefined,
+        useCase: isCliOption(command, "useCase") ? options.useCase : undefined,
+        command: isCliOption(command, "command") ? options.command : undefined,
+        query: isCliOption(command, "query") ? options.query : undefined,
+        auth: isCliOption(command, "auth") ? options.auth : undefined,
+        zone: isCliOption(command, "zone") ? options.zone : undefined,
+    };
+}
+function isCliOption(command, name) {
+    return command.getOptionValueSource(name) === "cli";
+}
+function enableBruno(config) {
+    if (!config.project.capabilities.apiClient.includes("bruno")) {
+        config.project.capabilities.apiClient.push("bruno");
+    }
+    config.api.bruno.enabled = true;
+    config.api.bruno.collectionPath ||= "bruno";
+    config.api.bruno.environment ||= "Local";
+}
+function routeControllerNamesForResource(generatedPaths, featuresRoot, resourceName, nextControllerPath) {
+    const apiPrefix = `${featuresRoot}/${resourceName}/api/`;
+    const routeControllerPaths = generatedPaths
+        .filter((filePath) => filePath.startsWith(apiPrefix))
+        .map(route_plan_1.routeControllerNameFromPath)
+        .filter((name) => Boolean(name))
+        .filter((name) => name !== resourceName);
+    const nextName = (0, route_plan_1.routeControllerNameFromPath)(nextControllerPath);
+    if (nextName) {
+        routeControllerPaths.push(nextName);
+    }
+    return Array.from(new Set(routeControllerPaths));
+}
+function routeControllerIndexResources(generatedPaths, featuresRoot, nextResourceName) {
+    const resources = generatedPaths
+        .map((filePath) => (0, route_plan_1.routeControllerIndexResourceFromPath)(filePath, featuresRoot))
+        .filter((name) => Boolean(name));
+    if (nextResourceName) {
+        resources.push(nextResourceName);
+    }
+    return Array.from(new Set(resources));
+}
+function commandNamesForFeature(generatedPaths, featuresRoot, feature, nextCommandName) {
+    const commandsPrefix = `${featuresRoot}/${feature}/application/commands/`;
+    const names = generatedPaths
+        .filter((filePath) => filePath.startsWith(commandsPrefix))
+        .map(command_plan_1.commandNameFromPath)
+        .filter((name) => Boolean(name));
+    names.push(nextCommandName);
+    return Array.from(new Set(names));
+}
+function commandFeatures(generatedPaths, featuresRoot, nextFeature) {
+    const features = generatedPaths
+        .map((filePath) => (0, command_plan_1.commandFeatureFromPath)(filePath, featuresRoot))
+        .filter((name) => Boolean(name));
+    if (nextFeature) {
+        features.push(nextFeature);
+    }
+    return Array.from(new Set(features));
+}
+function queryNamesForFeature(generatedPaths, featuresRoot, feature, nextQueryName) {
+    const queriesPrefix = `${featuresRoot}/${feature}/application/queries/`;
+    const names = generatedPaths
+        .filter((filePath) => filePath.startsWith(queriesPrefix))
+        .map(query_plan_1.queryNameFromPath)
+        .filter((name) => Boolean(name));
+    names.push(nextQueryName);
+    return Array.from(new Set(names));
+}
+function queryFeatures(generatedPaths, featuresRoot, nextFeature) {
+    const features = generatedPaths
+        .map((filePath) => (0, query_plan_1.queryFeatureFromPath)(filePath, featuresRoot))
+        .filter((name) => Boolean(name));
+    if (nextFeature) {
+        features.push(nextFeature);
+    }
+    return Array.from(new Set(features));
+}
+function collect(value, previous) {
+    previous.push(value);
+    return previous;
+}