@soapjs/cli 1.0.0

package/build/commands/remove/remove.command.js

@@ -0,0 +1,328 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRemoveCommand = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const load_soap_config_1 = require("../../config/load-soap-config");
+const write_soap_config_1 = require("../../config/write-soap-config");
+const command_context_1 = require("../../core/command-context");
+const errors_1 = require("../../core/errors");
+const file_writer_1 = require("../../io/file-writer");
+const conflict_policy_1 = require("../../io/conflict-policy");
+const registry_service_1 = require("../../registry/registry.service");
+const naming_1 = require("../../templates/naming");
+const resource_plan_1 = require("../add/resource-plan");
+const route_plan_1 = require("../add/route-plan");
+const common_options_1 = require("../shared/common-options");
+const prompts_1 = require("../../prompts");
+function registerRemoveCommand(program) {
+    const remove = program.command("remove").description("Safely remove generated resources and routes.");
+    (0, common_options_1.addConflictOption)((0, common_options_1.addInteractiveOption)(remove
+        .command("route <resource> <route>")
+        .description("Remove a generated route from a SoapJS project.")
+        .option("--force", "delete modified generated files", false)
+        .option("--yes", "skip interactive confirmation prompts", false)))
+        .action(async (resourceInput, routeInput, 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);
+        const resource = resolveResource(config, resourceInput);
+        const route = resolveRoute(config, resource, routeInput);
+        const targetEntries = routeFileEntries(config, resource, route);
+        const conflictPolicy = resolveRemoveConflictPolicy(options);
+        const preview = await createRemovePreview(config, targetEntries, [`route ${resource.name}/${route.name}`]);
+        if (options.interactive) {
+            context.output.info(formatRemovePreview(`Remove route ${resource.name}/${route.name}`, preview));
+            if (hasModifiedFiles(preview) && conflictPolicy !== "overwrite") {
+                throw new errors_1.CliError("Refusing to delete modified generated files. Use --force or --on-conflict overwrite to delete them.");
+            }
+            if (!options.yes) {
+                const confirmed = await new prompts_1.InquirerPromptAdapter().confirm({
+                    message: "Continue removal?",
+                    defaultValue: false,
+                });
+                if (!confirmed) {
+                    context.output.warn("Route removal aborted.");
+                    return;
+                }
+            }
+        }
+        const removePlan = await removeTrackedFiles(config, targetEntries, conflictPolicy, context);
+        if (removePlan.skipped.length > 0) {
+            reportRemoveResult(context, `Skipped route ${resource.name}/${route.name}`, removePlan);
+            return;
+        }
+        config.registry.routes = config.registry.routes.filter((entry) => entry !== route);
+        removeGeneratedEntries(config, removePlan.deleted);
+        await refreshGeneratedIndexes(config, removePlan.conflictPolicy === "overwrite", context, {
+            changedResource: resource,
+            deletedPaths: removePlan.deleted,
+        });
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        reportRemoveResult(context, `Removed route ${resource.name}/${route.name}`, removePlan);
+    });
+    (0, common_options_1.addConflictOption)((0, common_options_1.addInteractiveOption)(remove
+        .command("resource <resource>")
+        .description("Remove a generated resource from a SoapJS project.")
+        .option("--force", "delete modified generated files", false)
+        .option("--yes", "skip interactive confirmation prompts", false)))
+        .action(async (resourceInput, 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);
+        const resource = resolveResource(config, resourceInput);
+        const targetEntries = config.registry.generatedFiles.filter((entry) => entry.owner === resource.name);
+        const conflictPolicy = resolveRemoveConflictPolicy(options);
+        const routeCount = config.registry.routes.filter((entry) => entry.resource === resource.name).length;
+        const preview = await createRemovePreview(config, targetEntries, [
+            `resource ${resource.name}`,
+            `${routeCount} route${routeCount === 1 ? "" : "s"} for ${resource.name}`,
+        ]);
+        if (options.interactive) {
+            context.output.info(formatRemovePreview(`Remove resource ${resource.name}`, preview));
+            if (hasModifiedFiles(preview) && conflictPolicy !== "overwrite") {
+                throw new errors_1.CliError("Refusing to delete modified generated files. Use --force or --on-conflict overwrite to delete them.");
+            }
+            if (!options.yes) {
+                const confirmed = await new prompts_1.InquirerPromptAdapter().confirm({
+                    message: "Continue removal?",
+                    defaultValue: false,
+                });
+                if (!confirmed) {
+                    context.output.warn("Resource removal aborted.");
+                    return;
+                }
+            }
+        }
+        const removePlan = await removeTrackedFiles(config, targetEntries, conflictPolicy, context);
+        if (removePlan.skipped.length > 0) {
+            reportRemoveResult(context, `Skipped resource ${resource.name}`, removePlan);
+            return;
+        }
+        config.registry.resources = config.registry.resources.filter((entry) => entry !== resource);
+        config.registry.routes = config.registry.routes.filter((entry) => entry.resource !== resource.name);
+        removeGeneratedEntries(config, removePlan.deleted);
+        await refreshGeneratedIndexes(config, removePlan.conflictPolicy === "overwrite", context, {
+            deletedPaths: removePlan.deleted,
+        });
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        reportRemoveResult(context, `Removed resource ${resource.name}`, removePlan);
+    });
+}
+exports.registerRemoveCommand = registerRemoveCommand;
+function resolveResource(config, input) {
+    const names = (0, naming_1.createNameVariants)(input);
+    const candidates = new Set([input, names.kebabName, singularize(names.kebabName), names.pluralName]);
+    const resource = config.registry.resources.find((entry) => candidates.has(entry.name) || candidates.has(entry.path.replace(/^\//, "")));
+    if (!resource) {
+        throw new errors_1.CliError(`Resource "${input}" was not found in the route registry.`);
+    }
+    return resource;
+}
+function resolveRoute(config, resource, input) {
+    const resourceNames = (0, naming_1.createNameVariants)(resource.name);
+    const routeNames = (0, naming_1.createNameVariants)(input);
+    const candidates = new Set([
+        input,
+        routeNames.kebabName,
+        stripResourceSuffix(routeNames.kebabName, resourceNames.kebabName),
+        stripResourceSuffix(routeNames.kebabName, resourceNames.pluralName),
+    ]);
+    const route = config.registry.routes.find((entry) => entry.resource === resource.name && candidates.has(entry.name));
+    if (!route) {
+        throw new errors_1.CliError(`Route "${input}" was not found on resource "${resource.name}".`);
+    }
+    return route;
+}
+function stripResourceSuffix(value, resourceName) {
+    const suffix = `-${resourceName}`;
+    return value.endsWith(suffix) ? value.slice(0, -suffix.length) : value;
+}
+function resolveRemoveConflictPolicy(options) {
+    const policy = (0, conflict_policy_1.resolveConflictPolicy)({
+        force: options.force,
+        onConflict: options.onConflict,
+        skipModified: !options.force,
+    });
+    if (policy === "new") {
+        throw new errors_1.CliError("Conflict policy \"new\" is not supported for remove commands.");
+    }
+    return policy;
+}
+function singularize(value) {
+    return value.endsWith("s") ? value.slice(0, -1) : value;
+}
+async function createRemovePreview(config, entries, registryEntries) {
+    const files = await Promise.all(entries.map(async (entry) => {
+        const currentHash = await (0, registry_service_1.readFileHash)(path_1.default.join(config.root, entry.path));
+        return {
+            path: entry.path,
+            exists: currentHash !== undefined,
+            modified: Boolean(currentHash && currentHash !== entry.hash),
+        };
+    }));
+    return {
+        files,
+        registryEntries,
+    };
+}
+function formatRemovePreview(title, preview) {
+    const modifiedFiles = preview.files.filter((file) => file.modified);
+    const lines = [
+        title,
+        `Tracked files to delete: ${preview.files.length}`,
+        ...formatPreviewFiles(preview.files),
+        `Modified tracked files: ${modifiedFiles.length}`,
+        ...formatPreviewFiles(modifiedFiles),
+        `Registry entries to remove: ${preview.registryEntries.length}`,
+        ...preview.registryEntries.map((entry) => `- ${entry}`),
+    ];
+    return lines.join("\n");
+}
+function formatPreviewFiles(files) {
+    if (files.length === 0) {
+        return ["- none"];
+    }
+    return files.map((file) => {
+        const suffix = file.modified ? " (modified)" : file.exists ? "" : " (missing)";
+        return `- ${file.path}${suffix}`;
+    });
+}
+function hasModifiedFiles(preview) {
+    return preview.files.some((file) => file.modified);
+}
+function routeFileEntries(config, resource, route) {
+    const resourceNames = (0, naming_1.createNameVariants)(resource.name);
+    const routeNames = (0, naming_1.createNameVariants)(route.name);
+    const routeFileNames = new Set([
+        routeNames.kebabName,
+        `${routeNames.kebabName}-${resourceNames.kebabName}`,
+        `${routeNames.kebabName}-${resourceNames.pluralName}`,
+    ]);
+    const brunoPath = path_1.default.posix.join(config.api.bruno.collectionPath, resourceNames.pascalName, `${routeNames.pascalName}.bru`);
+    return config.registry.generatedFiles.filter((entry) => {
+        if (entry.path === brunoPath) {
+            return true;
+        }
+        if (entry.owner !== resource.name || entry.type !== "route") {
+            return false;
+        }
+        const fileName = path_1.default.posix.basename(entry.path).replace(/\.(controller|contract)\.ts$/, "");
+        return routeFileNames.has(fileName);
+    });
+}
+async function removeTrackedFiles(config, entries, conflictPolicy, context) {
+    const deleted = [];
+    const skipped = [];
+    const currentHashes = new Map();
+    for (const entry of entries) {
+        const absolutePath = path_1.default.join(config.root, entry.path);
+        const currentHash = await (0, registry_service_1.readFileHash)(absolutePath);
+        currentHashes.set(entry.path, currentHash);
+        if (currentHash && currentHash !== entry.hash && conflictPolicy !== "overwrite") {
+            if (conflictPolicy === "abort") {
+                throw new errors_1.CliError(`Refusing to delete modified file ${entry.path}. Use --force or --on-conflict overwrite to delete it.`);
+            }
+            if (conflictPolicy === "ask") {
+                throw new errors_1.CliError(`Interactive conflict resolution is not available yet for ${entry.path}. Use --on-conflict skip, overwrite, or abort.`);
+            }
+            skipped.push(entry.path);
+            context.output.warn(`Skipped modified file ${entry.path}. Use --force to delete it.`);
+        }
+    }
+    if (skipped.length > 0) {
+        return { deleted, skipped, conflictPolicy };
+    }
+    for (const entry of entries) {
+        const absolutePath = path_1.default.join(config.root, entry.path);
+        const currentHash = currentHashes.get(entry.path);
+        if (!currentHash) {
+            deleted.push(entry.path);
+        }
+        else if (context.dryRun) {
+            context.output.info(`[dry-run] delete ${absolutePath}`);
+        }
+        else {
+            await promises_1.default.unlink(absolutePath);
+            await pruneEmptyParents(path_1.default.dirname(absolutePath), config.root);
+        }
+        if (currentHash) {
+            deleted.push(entry.path);
+        }
+    }
+    return { deleted, skipped, conflictPolicy };
+}
+async function pruneEmptyParents(startPath, root) {
+    let current = startPath;
+    while (current.startsWith(root) && current !== root) {
+        try {
+            await promises_1.default.rmdir(current);
+        }
+        catch (error) {
+            return;
+        }
+        current = path_1.default.dirname(current);
+    }
+}
+function removeGeneratedEntries(config, deletedPaths) {
+    const deleted = new Set(deletedPaths);
+    config.registry.generatedFiles = config.registry.generatedFiles.filter((entry) => !deleted.has(entry.path));
+}
+async function refreshGeneratedIndexes(config, force, context, options) {
+    const generatedPaths = config.registry.generatedFiles.map((entry) => entry.path);
+    const routeIndexResources = routeControllerIndexResources(generatedPaths, config.structure.featuresRoot);
+    const files = [
+        (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, routeIndexResources, config.registry.resources.filter((resource) => !routeIndexResources.includes(resource.name)).map((resource) => resource.name)),
+    ];
+    if (options.changedResource && config.registry.resources.includes(options.changedResource)) {
+        const routeNames = routeControllerNamesForResource(generatedPaths, config.structure.featuresRoot, options.changedResource.name);
+        const indexPath = path_1.default.posix.join(config.structure.featuresRoot, options.changedResource.name, "api", `${options.changedResource.name}.controllers.ts`);
+        if (routeNames.length > 0) {
+            files.push((0, route_plan_1.createRouteControllersIndexFile)(options.changedResource, config.structure.featuresRoot, routeNames));
+        }
+        else {
+            const indexEntry = config.registry.generatedFiles.find((entry) => entry.path === indexPath);
+            if (indexEntry) {
+                const removePlan = await removeTrackedFiles(config, [indexEntry], force ? "overwrite" : "skip", context);
+                removeGeneratedEntries(config, removePlan.deleted);
+            }
+        }
+    }
+    await (0, file_writer_1.writePlannedFiles)({
+        root: config.root,
+        files,
+        registry: config.registry,
+        force,
+        skipModified: !force,
+    }, context);
+}
+function routeControllerNamesForResource(generatedPaths, featuresRoot, resourceName) {
+    const apiPrefix = `${featuresRoot}/${resourceName}/api/`;
+    return Array.from(new Set(generatedPaths
+        .filter((filePath) => filePath.startsWith(apiPrefix))
+        .map(route_plan_1.routeControllerNameFromPath)
+        .filter((name) => Boolean(name))
+        .filter((name) => name !== resourceName))).sort();
+}
+function routeControllerIndexResources(generatedPaths, featuresRoot) {
+    return Array.from(new Set(generatedPaths
+        .map((filePath) => (0, route_plan_1.routeControllerIndexResourceFromPath)(filePath, featuresRoot))
+        .filter((name) => Boolean(name)))).sort();
+}
+function reportRemoveResult(context, message, plan) {
+    if (plan.skipped.length > 0 && plan.deleted.length === 0) {
+        context.output.warn(`${message}; ${plan.skipped.length} modified files left untouched. Use --force to remove them.`);
+        return;
+    }
+    const suffix = plan.skipped.length > 0 ? ` (${plan.skipped.length} modified files skipped)` : "";
+    if (context.dryRun) {
+        context.output.success(`${message.replace(/^Removed/, "Would remove")}; would delete ${plan.deleted.length} files${suffix}.`);
+        return;
+    }
+    context.output.success(`${message}; deleted ${plan.deleted.length} files${suffix}.`);
+}

package/build/commands/shared/common-options.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+export interface InteractiveCommandOptions {
+    interactive?: boolean;
+}
+export interface ConflictCommandOptions {
+    onConflict?: string;
+}
+export declare function addInteractiveOption<T extends Command>(command: T): T;
+export declare function addConflictOption<T extends Command>(command: T): T;
+export declare function assertInteractiveTerminal(options: InteractiveCommandOptions): void;

package/build/commands/shared/common-options.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertInteractiveTerminal = exports.addConflictOption = exports.addInteractiveOption = void 0;
+const errors_1 = require("../../core/errors");
+const conflict_policy_1 = require("../../io/conflict-policy");
+const terminal_capabilities_1 = require("../../terminal/terminal-capabilities");
+function addInteractiveOption(command) {
+    return command.option("-i, --interactive", "run a guided interactive flow", false);
+}
+exports.addInteractiveOption = addInteractiveOption;
+function addConflictOption(command) {
+    return command.option("--on-conflict <policy>", `file conflict policy: ${(0, conflict_policy_1.conflictPolicyHelp)()}`);
+}
+exports.addConflictOption = addConflictOption;
+function assertInteractiveTerminal(options) {
+    if (!options.interactive) {
+        return;
+    }
+    if (!(0, terminal_capabilities_1.canRunInteractiveMode)()) {
+        throw new errors_1.CliError("Interactive mode requires a TTY. Use explicit flags instead.");
+    }
+}
+exports.assertInteractiveTerminal = assertInteractiveTerminal;

package/build/commands/update/update.command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerUpdateCommand(program: Command): void;

package/build/commands/update/update.command.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUpdateCommand = void 0;
+const load_soap_config_1 = require("../../config/load-soap-config");
+const write_soap_config_1 = require("../../config/write-soap-config");
+const command_context_1 = require("../../core/command-context");
+const errors_1 = require("../../core/errors");
+const dependency_resolver_1 = require("../../dependencies/dependency-resolver");
+const file_writer_1 = require("../../io/file-writer");
+const bruno_plan_1 = require("../generate/bruno-plan");
+const project_plan_1 = require("../create/project-plan");
+const resource_plan_1 = require("../add/resource-plan");
+const route_plan_1 = require("../add/route-plan");
+const common_options_1 = require("../shared/common-options");
+function registerUpdateCommand(program) {
+    const update = program.command("update").description("Update generated SoapJS project configuration.");
+    (0, common_options_1.addConflictOption)(update
+        .command("config")
+        .description("Add project capabilities and generated infrastructure.")
+        .option("--add-db <database>", "add database capability: mongo, postgres, mysql, sqlite, redis", collect, [])
+        .option("--add-auth <auth>", "add auth capability: jwt, api-key, local", collect, [])
+        .option("--add-docs <docs>", "add docs capability: openapi", collect, [])
+        .option("--add-contracts <contracts>", "add contract capability: zod", collect, [])
+        .option("--add-api-client <client>", "add API client capability: bruno", collect, [])
+        .option("--add-realtime <realtime>", "add realtime capability: ws", collect, [])
+        .option("--force", "overwrite generated infra files even when modified", false))
+        .action(async (options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const nextCapabilities = cloneCapabilities(config.project.capabilities);
+        const changes = [];
+        addCapabilities(nextCapabilities.databases, (0, project_plan_1.parseCsvOption)(options.addDb, project_plan_1.databaseOptions), "db", changes);
+        addCapabilities(nextCapabilities.auth, (0, project_plan_1.parseCsvOption)(options.addAuth, project_plan_1.authOptions), "auth", changes);
+        addCapabilities(nextCapabilities.docs, (0, project_plan_1.parseCsvOption)(options.addDocs, project_plan_1.docsOptions), "docs", changes);
+        addCapabilities(nextCapabilities.contracts, (0, project_plan_1.parseCsvOption)(options.addContracts, project_plan_1.contractsOptions), "contracts", changes);
+        addCapabilities(nextCapabilities.apiClient, (0, project_plan_1.parseCsvOption)(options.addApiClient, ["bruno"]), "api-client", changes);
+        addCapabilities(nextCapabilities.realtime, (0, project_plan_1.parseCsvOption)(options.addRealtime, project_plan_1.realtimeOptions), "realtime", changes);
+        if (changes.length === 0) {
+            throw new errors_1.CliError("No new capabilities requested. Use --add-db, --add-auth, --add-docs, --add-contracts, --add-api-client, or --add-realtime.");
+        }
+        config.project.capabilities = nextCapabilities;
+        updateApiConfig(config);
+        const plan = createPlan(config);
+        const files = createUpdateFiles(config, plan);
+        if (context.dryRun) {
+            context.output.info(`Capabilities: ${changes.join(", ")}`);
+            context.output.info(`Files: ${files.length}`);
+        }
+        await (0, file_writer_1.writePlannedFiles)({
+            root: config.root,
+            files,
+            registry: config.registry,
+            force: options.force,
+            onConflict: options.onConflict,
+            skipModified: !options.force,
+        }, context);
+        await (0, write_soap_config_1.writeSoapConfig)(config.root, config, context);
+        context.output.success(`Updated project capabilities: ${changes.join(", ")}.`);
+    });
+}
+exports.registerUpdateCommand = registerUpdateCommand;
+function collect(value, previous) {
+    previous.push(value);
+    return previous;
+}
+function cloneCapabilities(capabilities) {
+    return {
+        databases: [...capabilities.databases],
+        auth: [...capabilities.auth],
+        messaging: [...capabilities.messaging],
+        realtime: [...capabilities.realtime],
+        telemetry: [...capabilities.telemetry],
+        apiClient: [...capabilities.apiClient],
+        docs: [...capabilities.docs],
+        contracts: [...capabilities.contracts],
+    };
+}
+function addCapabilities(target, values, label, changes) {
+    for (const value of values) {
+        if (!target.includes(value)) {
+            target.push(value);
+            changes.push(`${label}:${value}`);
+        }
+    }
+}
+function updateApiConfig(config) {
+    config.api.bruno.enabled = config.project.capabilities.apiClient.includes("bruno");
+    config.api.bruno.collectionPath ||= "bruno";
+    config.api.bruno.environment ||= "Local";
+    const defaultAuth = config.project.capabilities.auth[0] ?? "none";
+    config.api.auth.default = defaultAuth;
+    config.api.auth.loginRoute =
+        defaultAuth === "jwt" || defaultAuth === "local"
+            ? {
+                method: "POST",
+                path: "/auth/login",
+                tokenVariable: "accessToken",
+            }
+            : undefined;
+}
+function createPlan(config) {
+    return {
+        name: config.project.name,
+        root: config.root,
+        framework: config.project.framework,
+        architecture: config.project.architecture,
+        packageManager: config.project.packageManager,
+        capabilities: config.project.capabilities,
+        zones: config.project.zones,
+        dependencies: (0, dependency_resolver_1.resolveDependencies)(config.project.capabilities),
+    };
+}
+function createUpdateFiles(config, plan) {
+    const projectFiles = (0, project_plan_1.createProjectFiles)(plan).filter(shouldUpdateFromProjectPlan);
+    const routeControllerIndexes = routeControllerIndexResources(config.registry.generatedFiles.map((file) => file.path), config.structure.featuresRoot);
+    const mainControllerResources = config.registry.resources
+        .filter((resource) => !routeControllerIndexes.includes(resource.name))
+        .map((resource) => resource.name);
+    const indexFiles = [
+        (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),
+    ];
+    const brunoFiles = config.api.bruno.enabled ? (0, bruno_plan_1.createBrunoFiles)(config) : [];
+    return mergeFiles([...projectFiles, ...indexFiles, ...brunoFiles]);
+}
+function shouldUpdateFromProjectPlan(file) {
+    if ([
+        "package.json",
+        ".env.example",
+        "README.md",
+        "docker-compose.yml",
+        "src/index.ts",
+        "src/config/config.ts",
+        "src/config/dependencies.ts",
+    ].includes(file.path)) {
+        return true;
+    }
+    return (/^src\/config\/[^/]+\.config\.ts$/.test(file.path) ||
+        file.path.startsWith("src/common/") ||
+        file.path.startsWith("src/features/auth/") ||
+        file.path.startsWith("src/features/health/"));
+}
+function mergeFiles(files) {
+    const byPath = new Map();
+    for (const file of files) {
+        byPath.set(file.path, file);
+    }
+    return Array.from(byPath.values());
+}
+function routeControllerIndexResources(generatedPaths, featuresRoot) {
+    return Array.from(new Set(generatedPaths
+        .map((filePath) => (0, route_plan_1.routeControllerIndexResourceFromPath)(filePath, featuresRoot))
+        .filter((name) => Boolean(name)))).sort();
+}

package/build/config/auth-policy.d.ts

@@ -0,0 +1,4 @@
+import { AuthPolicy } from "./schemas/types";
+export declare function parseAuthPolicy(value: string | undefined): AuthPolicy | undefined;
+export declare function formatAuthPolicy(policy: AuthPolicy | undefined): string | undefined;
+export declare function createAuthPolicyArgument(policy: AuthPolicy | undefined): string | undefined;

package/build/config/auth-policy.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthPolicyArgument = exports.formatAuthPolicy = exports.parseAuthPolicy = void 0;
+const errors_1 = require("../core/errors");
+function parseAuthPolicy(value) {
+    if (!value || value === "none") {
+        return undefined;
+    }
+    if (value === "admin") {
+        return { type: "admin" };
+    }
+    if (value.startsWith("roles:")) {
+        const roles = value.slice("roles:".length).split(",").map((role) => role.trim()).filter(Boolean);
+        if (roles.length === 0) {
+            throw new errors_1.CliError("Auth policy roles must include at least one role.");
+        }
+        return { type: "roles", roles };
+    }
+    if (value.startsWith("custom:")) {
+        const name = value.slice("custom:".length).trim();
+        if (!name) {
+            throw new errors_1.CliError("Custom auth policy must include a name.");
+        }
+        return { type: "custom", name };
+    }
+    throw new errors_1.CliError(`Invalid auth policy "${value}". Use admin, roles:a,b, custom:name, or none.`);
+}
+exports.parseAuthPolicy = parseAuthPolicy;
+function formatAuthPolicy(policy) {
+    if (!policy) {
+        return undefined;
+    }
+    if (policy.type === "admin") {
+        return "admin";
+    }
+    if (policy.type === "roles") {
+        return `roles:${policy.roles.join(",")}`;
+    }
+    return `custom:${policy.name}`;
+}
+exports.formatAuthPolicy = formatAuthPolicy;
+function createAuthPolicyArgument(policy) {
+    if (!policy) {
+        return undefined;
+    }
+    if (policy.type === "admin") {
+        return "{ policy: 'admin' }";
+    }
+    if (policy.type === "roles") {
+        return `{ roles: [${policy.roles.map((role) => `'${role}'`).join(", ")}] }`;
+    }
+    return `{ policy: '${policy.name}' }`;
+}
+exports.createAuthPolicyArgument = createAuthPolicyArgument;

package/build/config/find-soap-root.d.ts

@@ -0,0 +1 @@
+export declare function findSoapRoot(cwd: string): string | undefined;

package/build/config/find-soap-root.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSoapRoot = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function findSoapRoot(cwd) {
+    let current = path_1.default.resolve(cwd);
+    while (true) {
+        if (fs_1.default.existsSync(path_1.default.join(current, ".soap", "project.json"))) {
+            return current;
+        }
+        const parent = path_1.default.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+exports.findSoapRoot = findSoapRoot;

package/build/config/load-soap-config.d.ts

@@ -0,0 +1,2 @@
+import { SoapConfig } from "./schemas/types";
+export declare function loadSoapConfig(cwd: string): Promise<SoapConfig>;

package/build/config/load-soap-config.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSoapConfig = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../core/errors");
+const find_soap_root_1 = require("./find-soap-root");
+const validation_1 = require("./schemas/validation");
+async function readJson(filePath) {
+    const content = await promises_1.default.readFile(filePath, "utf8");
+    return JSON.parse(content);
+}
+async function loadSoapConfig(cwd) {
+    const root = (0, find_soap_root_1.findSoapRoot)(cwd);
+    if (!root) {
+        throw new errors_1.CliError("This command must be run inside a SoapJS project. Run `soap create <name>` first.");
+    }
+    const soapRoot = path_1.default.join(root, ".soap");
+    return {
+        root,
+        project: (0, validation_1.validateProjectConfig)(await readJson(path_1.default.join(soapRoot, "project.json"))),
+        structure: (0, validation_1.validateStructureConfig)(await readJson(path_1.default.join(soapRoot, "structure.json"))),
+        api: (0, validation_1.validateApiConfig)(await readJson(path_1.default.join(soapRoot, "api.json"))),
+        registry: (0, validation_1.validateRegistryConfig)(await readJson(path_1.default.join(soapRoot, "registry.json"))),
+    };
+}
+exports.loadSoapConfig = loadSoapConfig;