@soapjs/cli 1.0.0

package/build/commands/add/route-plan.d.ts

@@ -0,0 +1,24 @@
+import { ApiZone, AuthCapability, AuthPolicy, ResourceRegistryEntry, RouteRegistryEntry } from "../../config/schemas/types";
+import { PlannedFile } from "../../io/file-writer";
+export type RouteMethod = "get" | "post" | "put" | "patch" | "delete" | "head" | "options";
+export interface AddRoutePlan {
+    resource: ResourceRegistryEntry;
+    name: string;
+    method: RouteMethod;
+    path?: string;
+    useCase?: string;
+    command?: string;
+    query?: string;
+    auth: "none" | AuthCapability;
+    zone: ApiZone;
+    policy?: AuthPolicy;
+    featuresRoot: string;
+    contracts?: "plain" | "zod";
+}
+export declare const routeMethods: RouteMethod[];
+export declare function createRouteEntry(plan: AddRoutePlan): RouteRegistryEntry;
+export declare function createRouteControllerFile(plan: AddRoutePlan): PlannedFile;
+export declare function createRouteControllersIndexFile(resource: ResourceRegistryEntry, featuresRoot: string, routeNames: string[]): PlannedFile;
+export declare function createRouteContractFile(plan: AddRoutePlan): PlannedFile;
+export declare function routeControllerNameFromPath(filePath: string): string | undefined;
+export declare function routeControllerIndexResourceFromPath(filePath: string, featuresRoot: string): string | undefined;

package/build/commands/add/route-plan.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeControllerIndexResourceFromPath = exports.routeControllerNameFromPath = exports.createRouteContractFile = exports.createRouteControllersIndexFile = exports.createRouteControllerFile = exports.createRouteEntry = exports.routeMethods = void 0;
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../../core/errors");
+const naming_1 = require("../../templates/naming");
+const resource_plan_1 = require("./resource-plan");
+const auth_policy_1 = require("../../config/auth-policy");
+const decoratorByMethod = {
+    get: "Get",
+    post: "Post",
+    put: "Put",
+    patch: "Patch",
+    delete: "Delete",
+    head: "Head",
+    options: "Options",
+};
+exports.routeMethods = ["get", "post", "put", "patch", "delete", "head", "options"];
+function createRouteEntry(plan) {
+    const names = (0, naming_1.createNameVariants)(plan.name);
+    const absolutePath = resolveRoutePath(plan.resource.path, names.kebabName, plan.path);
+    return {
+        resource: plan.resource.name,
+        name: names.kebabName,
+        method: plan.method.toUpperCase(),
+        path: absolutePath,
+        auth: plan.auth,
+        zone: plan.zone,
+        policy: plan.policy,
+        generatedAt: new Date().toISOString(),
+    };
+}
+exports.createRouteEntry = createRouteEntry;
+function createRouteControllerFile(plan) {
+    const resourceNames = (0, naming_1.createNameVariants)(plan.resource.name);
+    const routeNames = (0, naming_1.createNameVariants)(plan.name);
+    const controllerPath = path_1.default.posix.join(plan.featuresRoot, resourceNames.kebabName, "api", `${routeNames.kebabName}.controller.ts`);
+    return {
+        path: controllerPath,
+        type: "route",
+        owner: resourceNames.kebabName,
+        content: createRouteControllerTs(plan),
+    };
+}
+exports.createRouteControllerFile = createRouteControllerFile;
+function createRouteControllersIndexFile(resource, featuresRoot, routeNames) {
+    const resourceNames = (0, naming_1.createNameVariants)(resource.name);
+    const uniqueRouteNames = Array.from(new Set(routeNames)).sort();
+    const imports = uniqueRouteNames
+        .map((routeName) => {
+        const names = (0, naming_1.createNameVariants)(routeName);
+        return `import { ${names.pascalName}Controller } from './${names.kebabName}.controller';`;
+    })
+        .join("\n");
+    const controllers = uniqueRouteNames
+        .map((routeName) => `  ${(0, naming_1.createNameVariants)(routeName).pascalName}Controller,`)
+        .join("\n");
+    return {
+        path: path_1.default.posix.join(planFeatureRoot(featuresRoot, resourceNames.kebabName), "api", `${resourceNames.kebabName}.controllers.ts`),
+        type: "config",
+        owner: resourceNames.kebabName,
+        content: `${imports}
+
+export const ${resourceNames.pascalName}Controllers = [
+${controllers}
+];
+`,
+    };
+}
+exports.createRouteControllersIndexFile = createRouteControllersIndexFile;
+function createRouteContractFile(plan) {
+    const resourceNames = (0, naming_1.createNameVariants)(plan.resource.name);
+    const routeNames = (0, naming_1.createNameVariants)(plan.name);
+    const contractPath = path_1.default.posix.join(plan.featuresRoot, resourceNames.kebabName, "contracts", `${routeNames.kebabName}.contract.ts`);
+    return {
+        path: contractPath,
+        type: "route",
+        owner: resourceNames.kebabName,
+        content: createRouteContractTs(routeNames.pascalName, routeNames.camelName, plan.method, plan.contracts),
+    };
+}
+exports.createRouteContractFile = createRouteContractFile;
+function routeControllerNameFromPath(filePath) {
+    const match = filePath.match(/\/api\/([^/]+)\.controller\.ts$/);
+    const name = match?.[1];
+    if (!name || name.endsWith(".controllers")) {
+        return undefined;
+    }
+    return name;
+}
+exports.routeControllerNameFromPath = routeControllerNameFromPath;
+function routeControllerIndexResourceFromPath(filePath, featuresRoot) {
+    const escapedRoot = featuresRoot.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = filePath.match(new RegExp(`^${escapedRoot}/([^/]+)/api/\\1\\.controllers\\.ts$`));
+    return match?.[1];
+}
+exports.routeControllerIndexResourceFromPath = routeControllerIndexResourceFromPath;
+function createRouteControllerTs(plan) {
+    const resourceNames = (0, naming_1.createNameVariants)(plan.resource.name);
+    const routeNames = (0, naming_1.createNameVariants)(plan.name);
+    const useCaseNames = plan.useCase ? (0, naming_1.createNameVariants)(plan.useCase) : undefined;
+    const commandNames = plan.command ? (0, naming_1.createNameVariants)(plan.command) : undefined;
+    const queryNames = plan.query ? (0, naming_1.createNameVariants)(plan.query) : undefined;
+    const cqrsTarget = commandNames
+        ? {
+            kind: "command",
+            names: commandNames,
+            className: `${commandNames.pascalName}Command`,
+            busType: "CommandBus",
+            busProperty: "commandBus",
+            importPath: `../application/commands/${commandNames.kebabName}.command`,
+        }
+        : queryNames
+            ? {
+                kind: "query",
+                names: queryNames,
+                className: `${queryNames.pascalName}Query`,
+                busType: "QueryBus",
+                busProperty: "queryBus",
+                importPath: `../application/queries/${queryNames.kebabName}.query`,
+            }
+            : undefined;
+    const decorator = decoratorByMethod[plan.method];
+    const routePath = toControllerRoutePath(plan.resource.path, resolveRoutePath(plan.resource.path, routeNames.kebabName, plan.path));
+    const soapImports = createSoapExpressImports(plan, decorator);
+    const expressImport = cqrsTarget ? "import { Request } from 'express';\n" : "";
+    const cqrsImport = cqrsTarget ? `import { ${cqrsTarget.busType} } from '@soapjs/soap/cqrs';\n` : "";
+    const cqrsTargetImport = cqrsTarget ? `import { ${cqrsTarget.className} } from '${cqrsTarget.importPath}';\n` : "";
+    const useCaseImport = useCaseNames
+        ? `import { ${useCaseNames.pascalName}UseCase } from '../application/use-cases/${useCaseNames.kebabName}.use-case';\n`
+        : "";
+    const contractImport = useCaseNames || cqrsTarget
+        ? `import { ${routeNames.camelName}BodyContract } from '../contracts/${routeNames.kebabName}.contract';\n`
+        : "";
+    const authDecorator = createRouteAuthDecorator(plan.auth, plan.zone, plan.policy);
+    const authLine = authDecorator ? `  ${authDecorator}\n` : "";
+    const useCaseDecorators = useCaseNames
+        ? `  @CallUseCase(${useCaseNames.pascalName}UseCase)\n  @RouteIO({ from: ${routeNames.camelName}BodyContract })\n`
+        : "";
+    const constructor = cqrsTarget
+        ? `  constructor(@Inject('${cqrsTarget.busType}') private readonly ${cqrsTarget.busProperty}: ${cqrsTarget.busType}) {}\n\n`
+        : "";
+    const methodArgs = cqrsTarget ? "req: Request" : "";
+    const body = cqrsTarget
+        ? `\n    return this.${cqrsTarget.busProperty}.dispatch(new ${cqrsTarget.className}(${routeNames.camelName}BodyContract(req)));\n  `
+        : useCaseNames
+            ? ""
+            : `\n    return { resource: '${resourceNames.kebabName}', action: '${routeNames.kebabName}' };\n  `;
+    const returnType = useCaseNames ? "void" : "unknown";
+    return `${expressImport}${soapImports}
+${cqrsImport}${cqrsTargetImport}${useCaseImport}${contractImport}
+@Controller('${plan.resource.path}', {
+  apiDoc: {
+    tags: ['${resourceNames.pascalName}'],
+    description: '${routeNames.pascalName} route generated by SoapJS CLI',
+  },
+})
+export class ${routeNames.pascalName}Controller {
+${constructor}${authLine}${useCaseDecorators}  @${decorator}('${routePath}', ${(0, resource_plan_1.createRouteApiDocOptions)({
+        summary: `${routeNames.camelName} ${resourceNames.kebabName}`,
+        operationId: routeNames.camelName,
+        auth: plan.auth,
+    })})
+  async ${routeNames.camelName}(${methodArgs}): Promise<${returnType}> {${body}}
+}
+`;
+}
+function createSoapExpressImports(plan, routeDecorator) {
+    const imports = new Set(["Controller", routeDecorator]);
+    if (plan.useCase) {
+        imports.add("CallUseCase");
+        imports.add("RouteIO");
+    }
+    if (plan.command || plan.query) {
+        imports.add("Inject");
+    }
+    const authDecorator = createRouteAuthDecorator(plan.auth, plan.zone, plan.policy);
+    if (authDecorator?.startsWith("@Public"))
+        imports.add("Public");
+    if (authDecorator?.startsWith("@Auth"))
+        imports.add("Auth");
+    if (authDecorator?.startsWith("@AdminOnly"))
+        imports.add("AdminOnly");
+    return `import { ${Array.from(imports).sort().join(", ")} } from '@soapjs/soap-express';`;
+}
+function createRouteAuthDecorator(auth, zone, policy) {
+    if (zone === "public") {
+        return "@Public()";
+    }
+    if (auth === "none") {
+        return undefined;
+    }
+    const strategy = auth === "local" ? "jwt" : auth;
+    if (zone === "admin" || policy?.type === "admin") {
+        return `@AdminOnly('${strategy}')`;
+    }
+    const policyArgument = (0, auth_policy_1.createAuthPolicyArgument)(policy);
+    return policyArgument ? `@Auth('${strategy}', ${policyArgument})` : `@Auth('${strategy}')`;
+}
+function createRouteContractTs(className, camelName, method, contracts) {
+    const sourceExpression = method === "get" || method === "delete" || method === "head" || method === "options"
+        ? "{ ...req.params, ...req.query }"
+        : "{ ...req.params, ...req.query, ...req.body }";
+    if (contracts === "zod") {
+        return `import { Request } from 'express';
+import { z } from 'zod';
+
+export const ${camelName}BodySchema = z.record(z.unknown());
+
+export type ${className}RouteInput = z.infer<typeof ${camelName}BodySchema>;
+
+export function ${camelName}BodyContract(req: Request): ${className}RouteInput {
+  return ${camelName}BodySchema.parse(${sourceExpression});
+}
+`;
+    }
+    return `import { Request } from 'express';
+
+export interface ${className}RouteInput {
+  [key: string]: unknown;
+}
+
+export function ${camelName}BodyContract(req: Request): ${className}RouteInput {
+  return ${sourceExpression};
+}
+`;
+}
+function resolveRoutePath(resourcePath, routeName, routePath) {
+    if (!routePath) {
+        return normalizePath(`${resourcePath}/${routeName}`);
+    }
+    const normalized = normalizePath(routePath);
+    if (normalized === resourcePath || normalized.startsWith(`${resourcePath}/`)) {
+        return normalized;
+    }
+    if (!routePath.startsWith("/")) {
+        return normalizePath(`${resourcePath}/${routePath}`);
+    }
+    throw new errors_1.CliError(`Route path "${routePath}" must be under resource path "${resourcePath}".`);
+}
+function toControllerRoutePath(resourcePath, absoluteRoutePath) {
+    if (absoluteRoutePath === resourcePath) {
+        return "/";
+    }
+    return absoluteRoutePath.slice(resourcePath.length) || "/";
+}
+function normalizePath(value) {
+    const normalized = value.replace(/\/+/g, "/");
+    return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+function planFeatureRoot(featuresRoot, resourceName) {
+    return path_1.default.posix.join(featuresRoot, resourceName);
+}

package/build/commands/add/socket-plan.d.ts

@@ -0,0 +1,9 @@
+import { AuthCapability } from "../../config/schemas/types";
+import { PlannedFile } from "../../io/file-writer";
+export interface AddSocketPlan {
+    name: string;
+    feature: string;
+    auth: "none" | AuthCapability;
+    featuresRoot: string;
+}
+export declare function createSocketFiles(root: string, plan: AddSocketPlan): Promise<PlannedFile[]>;

package/build/commands/add/socket-plan.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSocketFiles = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../../core/errors");
+const naming_1 = require("../../templates/naming");
+async function createSocketFiles(root, plan) {
+    const socketNames = (0, naming_1.createNameVariants)(plan.name);
+    const featureNames = (0, naming_1.createNameVariants)(plan.feature);
+    const featureRoot = path_1.default.posix.join(plan.featuresRoot, featureNames.kebabName);
+    const socketPath = `${featureRoot}/api/sockets/${socketNames.kebabName}.socket.ts`;
+    return [
+        {
+            path: socketPath,
+            type: "resource",
+            owner: featureNames.kebabName,
+            content: createSocketTs(`${socketNames.pascalName}Socket`, `${socketNames.camelName}Socket`, socketNames.kebabName, plan.auth),
+        },
+        await createSocketsConfigFile(root, {
+            className: `${socketNames.pascalName}Socket`,
+            exportName: `${socketNames.camelName}Socket`,
+            importPath: `../${featureRoot.replace(/^src\//, "")}/api/sockets/${socketNames.kebabName}.socket`,
+        }),
+    ];
+}
+exports.createSocketFiles = createSocketFiles;
+function createSocketTs(className, exportName, eventName, auth) {
+    const authComment = auth === "none" ? "" : "\n    // TODO: validate socket auth before handling this message.\n";
+    return `import { SocketMessage, SocketServer } from '@soapjs/soap-node-socket';
+import { AppSocketHandler } from '../../../../common/sockets/socket.setup';
+
+export class ${className} implements AppSocketHandler {
+  readonly event = '${eventName}';
+
+  async handle(clientId: string, message: SocketMessage, server: SocketServer): Promise<void> {${authComment}
+    server.sendToClient(clientId, {
+      type: '${eventName}:ack',
+      payload: {
+        received: true,
+        input: message.payload,
+      },
+    });
+  }
+}
+
+export const ${exportName} = new ${className}();
+`;
+}
+async function createSocketsConfigFile(root, socket) {
+    const configPath = "src/config/sockets.ts";
+    const absolutePath = path_1.default.join(root, configPath);
+    let current;
+    try {
+        current = await promises_1.default.readFile(absolutePath, "utf8");
+    }
+    catch {
+        throw new errors_1.CliError("WebSocket config is missing. Create the project with `--realtime ws` first.");
+    }
+    if (current.includes(` ${socket.exportName} `) || current.includes(`{ ${socket.exportName} }`)) {
+        throw new errors_1.CliError(`Socket handler "${socket.exportName}" is already registered.`);
+    }
+    const importLine = `import { ${socket.exportName} } from '${socket.importPath}';`;
+    const withImport = `${importLine}\n${current}`;
+    const content = withImport.replace(/export const socketHandlers: AppSocketHandler\[] = \[([\s\S]*?)\];/, (_match, body) => {
+        const entries = body
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        entries.push(`  ${socket.exportName},`);
+        return `export const socketHandlers: AppSocketHandler[] = [\n${entries.join("\n")}\n];`;
+    });
+    return {
+        path: configPath,
+        type: "config",
+        content,
+    };
+}

package/build/commands/add/use-case-plan.d.ts

@@ -0,0 +1,7 @@
+import { PlannedFile } from "../../io/file-writer";
+export interface AddUseCasePlan {
+    name: string;
+    feature: string;
+    featuresRoot: string;
+}
+export declare function createUseCaseFiles(plan: AddUseCasePlan): PlannedFile[];

package/build/commands/add/use-case-plan.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUseCaseFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const naming_1 = require("../../templates/naming");
+function createUseCaseFiles(plan) {
+    const useCaseNames = (0, naming_1.createNameVariants)(plan.name);
+    const featureNames = (0, naming_1.createNameVariants)(plan.feature);
+    const root = path_1.default.posix.join(plan.featuresRoot, featureNames.kebabName, "application", "use-cases");
+    return [
+        {
+            path: `${root}/${useCaseNames.kebabName}.use-case.ts`,
+            type: "use-case",
+            owner: featureNames.kebabName,
+            content: createUseCaseTs(useCaseNames.pascalName, useCaseNames.constantName),
+        },
+        {
+            path: `${root}/${useCaseNames.kebabName}.use-case.spec.ts`,
+            type: "use-case",
+            owner: featureNames.kebabName,
+            content: createUseCaseSpecTs(useCaseNames.pascalName, useCaseNames.kebabName),
+        },
+    ];
+}
+exports.createUseCaseFiles = createUseCaseFiles;
+function createUseCaseTs(className, constantName) {
+    return `import { Inject, Injectable, Result, UseCase } from '@soapjs/soap';
+
+export interface ${className}Input {
+  [key: string]: unknown;
+}
+
+export interface ${className}Output {
+  [key: string]: unknown;
+}
+
+export interface ${className}Repository {
+  save(input: ${className}Input): Promise<${className}Output> | ${className}Output;
+}
+
+export const ${constantName}_REPOSITORY = '${className}Repository';
+
+@Injectable()
+export class ${className}UseCase implements UseCase<${className}Output> {
+  constructor(@Inject(${constantName}_REPOSITORY) private readonly repository: ${className}Repository) {}
+
+  async execute(input: ${className}Input): Promise<Result<${className}Output>> {
+    try {
+      const output = await this.repository.save(input);
+      return Result.withSuccess(output);
+    } catch (error) {
+      return Result.withFailure(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+}
+`;
+}
+function createUseCaseSpecTs(className, kebabName) {
+    return `import assert from 'node:assert/strict';
+import test from 'node:test';
+import { ${className}Repository, ${className}UseCase } from './${kebabName}.use-case';
+
+test('${className}UseCase returns a successful Result from the repository', async () => {
+  const repository: ${className}Repository = {
+    async save(input) {
+      return {
+        id: 'generated-id',
+        ...input,
+      };
+    },
+  };
+  const useCase = new ${className}UseCase(repository);
+
+  const result = await useCase.execute({ name: 'Ada' });
+
+  assert.equal(result.isSuccess(), true);
+  assert.deepEqual(result.content, {
+    id: 'generated-id',
+    name: 'Ada',
+  });
+});
+`;
+}

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

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

package/build/commands/check/check.command.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCheckCommand = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const load_soap_config_1 = require("../../config/load-soap-config");
+const command_context_1 = require("../../core/command-context");
+const errors_1 = require("../../core/errors");
+const naming_1 = require("../../templates/naming");
+const allowedZones = ["public", "private", "admin"];
+const allowedAuth = ["none", "jwt", "api-key"];
+function registerCheckCommand(program) {
+    const check = program.command("check").description("Validate generated SoapJS project metadata.");
+    check
+        .command("routes")
+        .description("Validate route registry consistency.")
+        .action(async (_options, command) => {
+        const context = (0, command_context_1.getCommandContext)(command);
+        const config = await (0, load_soap_config_1.loadSoapConfig)(context.cwd);
+        const errors = checkRoutes(config);
+        if (errors.length > 0) {
+            for (const error of errors) {
+                context.output.error(error);
+            }
+            throw new errors_1.CliError(`Route check failed with ${errors.length} issue${errors.length === 1 ? "" : "s"}.`);
+        }
+        context.output.success(`Route registry is valid (${config.registry.routes.length} routes).`);
+    });
+}
+exports.registerCheckCommand = registerCheckCommand;
+function checkRoutes(config) {
+    const errors = [];
+    const routeKeys = new Map();
+    const resourceNames = new Set(config.registry.resources.map((resource) => resource.name));
+    for (const route of config.registry.routes) {
+        const label = `${route.method.toUpperCase()} ${route.path}`;
+        const key = label.toLowerCase();
+        const duplicate = routeKeys.get(key);
+        if (duplicate) {
+            errors.push(`Duplicate route ${label} used by ${duplicate.resource}/${duplicate.name} and ${route.resource}/${route.name}.`);
+        }
+        else {
+            routeKeys.set(key, route);
+        }
+        if (!resourceNames.has(route.resource)) {
+            errors.push(`Route ${route.resource}/${route.name} references unknown resource "${route.resource}".`);
+        }
+        if (!allowedZones.includes(route.zone)) {
+            errors.push(`Route ${route.resource}/${route.name} uses unknown zone "${route.zone}".`);
+        }
+        else if (!config.project.zones.includes(route.zone)) {
+            errors.push(`Route ${route.resource}/${route.name} uses zone "${route.zone}" that is not enabled for this project.`);
+        }
+        if (!allowedAuth.includes(route.auth)) {
+            errors.push(`Route ${route.resource}/${route.name} uses unknown auth strategy "${route.auth}".`);
+        }
+        else if (route.auth !== "none" &&
+            !enabledRouteAuthValues(config.project.capabilities.auth).includes(route.auth)) {
+            errors.push(`Route ${route.resource}/${route.name} uses auth strategy "${route.auth}" that is not enabled for this project.`);
+        }
+        if (route.policy) {
+            errors.push(...checkAuthPolicy(route));
+        }
+        const contractPaths = expectedContractPaths(config, route);
+        if (!contractPaths.some((contractPath) => fs_1.default.existsSync(path_1.default.join(config.root, contractPath)))) {
+            errors.push(`Route ${route.resource}/${route.name} is missing contract file (${contractPaths.join(" or ")}).`);
+        }
+        if ((config.api.bruno.enabled || config.project.capabilities.apiClient.includes("bruno")) && route.bruno !== false) {
+            const brunoPath = expectedBrunoPath(config, route);
+            if (!fs_1.default.existsSync(path_1.default.join(config.root, brunoPath))) {
+                errors.push(`Route ${route.resource}/${route.name} is missing Bruno file ${brunoPath}.`);
+            }
+        }
+    }
+    return errors;
+}
+function checkAuthPolicy(route) {
+    const errors = [];
+    if (route.auth === "none") {
+        errors.push(`Route ${route.resource}/${route.name} uses auth policy without route auth.`);
+    }
+    if (route.policy?.type === "roles" && route.policy.roles.length === 0) {
+        errors.push(`Route ${route.resource}/${route.name} uses roles policy without roles.`);
+    }
+    if (route.policy?.type === "custom" && route.policy.name.trim().length === 0) {
+        errors.push(`Route ${route.resource}/${route.name} uses custom policy without a name.`);
+    }
+    return errors;
+}
+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 expectedContractPaths(config, route) {
+    const resourceNames = (0, naming_1.createNameVariants)(route.resource);
+    const routeNames = (0, naming_1.createNameVariants)(route.name);
+    const contractNames = Array.from(new Set([routeNames.kebabName, `${routeNames.kebabName}-${resourceNames.kebabName}`, `${routeNames.kebabName}-${resourceNames.pluralName}`]));
+    return contractNames.map((contractName) => path_1.default.posix.join(config.structure.featuresRoot, resourceNames.kebabName, config.structure.paths.contracts, `${contractName}.contract.ts`));
+}
+function expectedBrunoPath(config, route) {
+    const resourceNames = (0, naming_1.createNameVariants)(route.resource);
+    const routeNames = (0, naming_1.createNameVariants)(route.name);
+    return path_1.default.posix.join(config.api.bruno.collectionPath, resourceNames.pascalName, `${routeNames.pascalName}.bru`);
+}

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

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