zudojs-cli 2.1.2 → 2.2.0

package/dist/src/generators/resource/resource.checks.js

@@ -0,0 +1,52 @@
+/**
+ * zudojs-cli — What must hold before a resource schematic writes anything.
+ *
+ * Every check runs before the first file is written, so a refused run
+ * leaves the project exactly as it was: the schematic's own files must not
+ * exist (unless `--force`), the container key and the routes import must be
+ * free, and — when the schematic registers itself — the marker pairs it
+ * inserts into must be present. A missing marker used to be a warning
+ * printed after the files were written and the run had "succeeded", with
+ * the unregistered routes answering 404.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CLIValidationError } from "../../errors/index.js";
+import { resourceLayerPaths, } from "../../templates/resource/index.js";
+import { conflictingImport, planMarkerEdits } from "../../wiring/index.js";
+/**
+ * Throws a {@link CLIValidationError} when the schematic cannot be written
+ * cleanly; returns the schematic's own files that already exist (empty
+ * unless `force`).
+ */
+export function assertResourceWritable(input) {
+    const { cwd, schematic, names, layout, plan, wiring } = input;
+    const exists = (path) => existsSync(join(cwd, path));
+    const taken = plan.primary
+        .flatMap((layer) => resourceLayerPaths(names, layout, layer))
+        .filter(exists);
+    if (taken.length > 0 && !input.force) {
+        throw new CLIValidationError(`${schematic} "${names.slug}" already exists:\n${taken
+            .map((path) => `  - ${path}`)
+            .join("\n")}\nChoose another name, or re-run with --force to regenerate these files.`);
+    }
+    if (plan.register && exists(wiring.container)) {
+        const container = readFileSync(join(cwd, wiring.container), "utf-8");
+        if (container.includes(`${wiring.containerKey}:`) && taken.length === 0) {
+            throw new CLIValidationError(`${wiring.container} already constructs "${wiring.containerKey}" (a resource named "${names.slug}" exists elsewhere in this app). Choose another name.`);
+        }
+    }
+    const clash = plan.register
+        ? conflictingImport(cwd, wiring.routesIndex, wiring.routeImport)
+        : undefined;
+    if (clash !== undefined) {
+        throw new CLIValidationError(`${wiring.routesIndex} already imports the routes function ${schematic} "${names.slug}" would register (${clash.trim()}). Choose another name.`);
+    }
+    const { manualSteps } = planMarkerEdits(cwd, input.edits).outcome;
+    if (manualSteps.length > 0) {
+        throw new CLIValidationError(`Cannot register ${schematic} "${names.slug}": the files it registers into are missing their markers, so nothing was written.\n${manualSteps
+            .map((step) => `  - ${step}`)
+            .join("\n")}\nRestore the marker comments (or add the lines by hand and re-run with --force once the files exist).`);
+    }
+    return taken;
+}

package/dist/src/generators/resource/resource.generator.d.ts

@@ -4,8 +4,9 @@
  * Writes the files of a resource-family schematic (see `resource.plan.ts`)
  * and wires them: the routes are registered between the markers of the
  * nearest `routes/index.ts`, and the controller is constructed once, in the
- * app's `src/container.ts`. Running it twice for the same name fails with
- * the files that already exist; it never duplicates a registration.
+ * app's `src/container.ts`. Every precondition is checked before the first
+ * write (`resource.checks.ts`); running it twice for the same name fails
+ * with the files that already exist, and it never duplicates a registration.
  */
 import { type ResourceLayout } from "../../templates/resource/index.js";
 import { type ResourceSchematic } from "./resource.plan.js";
@@ -22,6 +23,7 @@ export interface GenerateResourceOptions {
 export interface ResourceGenerationResult {
     readonly files: readonly string[];
     readonly manualSteps: readonly string[];
+    /** The Prisma schema a model was appended to, when one was. */
+    readonly prismaSchema?: string;
 }
 export declare function generateResource(options: GenerateResourceOptions, cwd: string): Promise<ResourceGenerationResult>;
-//# sourceMappingURL=resource.generator.d.ts.map

package/dist/src/generators/resource/resource.generator.js

@@ -4,42 +4,39 @@
  * Writes the files of a resource-family schematic (see `resource.plan.ts`)
  * and wires them: the routes are registered between the markers of the
  * nearest `routes/index.ts`, and the controller is constructed once, in the
- * app's `src/container.ts`. Running it twice for the same name fails with
- * the files that already exist; it never duplicates a registration.
+ * app's `src/container.ts`. Every precondition is checked before the first
+ * write (`resource.checks.ts`); running it twice for the same name fails
+ * with the files that already exist, and it never duplicates a registration.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { CLIValidationError } from "../../errors/index.js";
 import { renderHttpUtils } from "../../templates/backendApp/index.js";
 import { hasPrismaModel, joinPath, renderPrismaModel, renderResourceLayers, resourceLayerPaths, resourceNames, resourceWiring, } from "../../templates/resource/index.js";
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
-import { MARKERS, applyMarkerEdits, conflictingImport, } from "../../wiring/index.js";
+import { MARKERS, applyMarkerEdits } from "../../wiring/index.js";
+import { assertResourceWritable } from "./resource.checks.js";
 import { planResource } from "./resource.plan.js";
 export async function generateResource(options, cwd) {
     const names = resourceNames(options.name);
     const { layout } = options;
     const plan = planResource(options.schematic);
     const exists = (path) => existsSync(join(cwd, path));
-    const primaryPaths = plan.primary.flatMap((layer) => resourceLayerPaths(names, layout, layer));
-    const taken = primaryPaths.filter(exists);
-    if (taken.length > 0 && options.force !== true) {
-        throw new CLIValidationError(`${options.schematic} "${names.slug}" already exists:\n${taken
-            .map((path) => `  - ${path}`)
-            .join("\n")}\nChoose another name, or re-run with --force to regenerate these files.`);
-    }
     const wiring = resourceWiring(names, layout);
-    if (plan.register && exists(wiring.container)) {
-        const container = readFileSync(join(cwd, wiring.container), "utf-8");
-        if (container.includes(`${wiring.containerKey}:`) && taken.length === 0) {
-            throw new CLIValidationError(`${wiring.container} already constructs "${wiring.containerKey}" (a resource named "${names.slug}" exists elsewhere in this app). Choose another name.`);
-        }
-    }
-    const clash = plan.register
-        ? conflictingImport(cwd, wiring.routesIndex, wiring.routeImport)
-        : undefined;
-    if (clash !== undefined) {
-        throw new CLIValidationError(`${wiring.routesIndex} already imports the routes function ${options.schematic} "${names.slug}" would register (${clash.trim()}). Choose another name.`);
-    }
+    const edits = plan.register
+        ? [
+            { file: wiring.routesIndex, marker: MARKERS.routeImports, line: wiring.routeImport },
+            { file: wiring.routesIndex, marker: MARKERS.routes, line: wiring.routeEntry },
+            ...wiring.containerImports.map((line) => ({
+                file: wiring.container,
+                marker: MARKERS.containerImports,
+                line,
+            })),
+            { file: wiring.container, marker: MARKERS.container, line: wiring.containerEntry },
+        ]
+        : [];
+    assertResourceWritable({
+        cwd, schematic: options.schematic, names, layout, plan, wiring, edits, force: options.force === true,
+    });
     const missingRequired = plan.required.filter((layer) => resourceLayerPaths(names, layout, layer).some((path) => !exists(path)));
     const files = renderResourceLayers(names, layout, [
         ...missingRequired,
@@ -53,24 +50,14 @@ export async function generateResource(options, cwd) {
     }
     const writesRepository = plan.primary.includes("repository") || missingRequired.includes("repository");
     const schemaPath = joinPath(layout.appRoot, "prisma", "schema.prisma");
+    let prismaSchema;
     if (layout.prisma && writesRepository && exists(schemaPath)) {
         const schema = readFileSync(join(cwd, schemaPath), "utf-8");
         if (!hasPrismaModel(schema, names.entity)) {
             files[schemaPath] = `${schema.replace(/\n*$/, "\n")}${renderPrismaModel(names)}`;
+            prismaSchema = schemaPath;
         }
     }
-    const edits = plan.register
-        ? [
-            { file: wiring.routesIndex, marker: MARKERS.routeImports, line: wiring.routeImport },
-            { file: wiring.routesIndex, marker: MARKERS.routes, line: wiring.routeEntry },
-            ...wiring.containerImports.map((line) => ({
-                file: wiring.container,
-                marker: MARKERS.containerImports,
-                line,
-            })),
-            { file: wiring.container, marker: MARKERS.container, line: wiring.containerEntry },
-        ]
-        : [];
     if (!options.dryRun) {
         await writeFileTree(cwd, files);
     }
@@ -82,6 +69,6 @@ export async function generateResource(options, cwd) {
     return {
         files: [...Object.keys(files), ...outcome.edited],
         manualSteps,
+        ...(prismaSchema === undefined ? {} : { prismaSchema }),
     };
 }
-//# sourceMappingURL=resource.generator.js.map

package/dist/src/generators/resource/resource.layout.d.ts

@@ -23,4 +23,3 @@ export interface ResourceLayoutInput {
  * @throws {CLIValidationError} When the selected service or module does not exist.
  */
 export declare function resolveResourceLayout(input: ResourceLayoutInput): ResourceLayout;
-//# sourceMappingURL=resource.layout.d.ts.map

package/dist/src/generators/resource/resource.layout.js

@@ -43,4 +43,3 @@ export function resolveResourceLayout(input) {
         prisma: existsSync(join(cwd, appRoot, "prisma", "schema.prisma")),
     };
 }
-//# sourceMappingURL=resource.layout.js.map

package/dist/src/generators/resource/resource.plan.d.ts

@@ -30,4 +30,3 @@ export interface ResourcePlan {
 }
 /** The {@link ResourcePlan} of each schematic. */
 export declare function planResource(schematic: ResourceSchematic): ResourcePlan;
-//# sourceMappingURL=resource.plan.d.ts.map

package/dist/src/generators/resource/resource.plan.js

@@ -52,4 +52,3 @@ export function planResource(schematic) {
             return { primary: ["dto"], required: [], register: false };
     }
 }
-//# sourceMappingURL=resource.plan.js.map

package/dist/src/generators/resource/resource.run.d.ts

@@ -2,7 +2,10 @@
  * zudojs-cli — Running a resource-family schematic for `zudojs generate`.
  */
 import type { CLIContext } from "../../cliType/cliType.type.js";
+import type { PackageManager } from "../../types/index.js";
 import type { ResourceSchematic } from "./resource.plan.js";
+/** Runs `file args` in `cwd`; `execCommand` unless a test injects one. */
+export type ResourceExec = (file: string, args: readonly string[], cwd: string) => Promise<unknown>;
 /** Inputs of {@link runResourceSchematic}. */
 export interface ResourceSchematicRun {
     readonly schematic: ResourceSchematic;
@@ -11,15 +14,22 @@ export interface ResourceSchematicRun {
     /** `""` or `"apps/api"` (fullstack). */
     readonly backendRoot: string;
     readonly architecture: string | undefined;
+    /** Runs `prisma generate` after a model is added; detected from lock files when omitted. */
+    readonly packageManager?: PackageManager;
     readonly service?: string;
     readonly moduleName?: string;
     readonly dryRun: boolean;
     readonly force: boolean;
+    readonly exec?: ResourceExec;
 }
+/** `<pm> exec prisma generate`, spelled the way each package manager wants it. */
+export declare function prismaGenerateCommand(packageManager: PackageManager): readonly [string, ...string[]];
 /**
  * Runs a resource-family schematic: writes the DTO → repository → service
  * → controller → routes chain it needs and registers the routes and the
- * controller between the project's markers.
+ * controller between the project's markers. When a model was appended to
+ * `prisma/schema.prisma`, runs `prisma generate` so the new Prisma-backed
+ * repository compiles at once (`prisma migrate dev` no longer regenerates
+ * the client); when that fails — nothing installed yet — it says what to run.
  */
 export declare function runResourceSchematic(context: CLIContext, run: ResourceSchematicRun): Promise<void>;
-//# sourceMappingURL=resource.run.d.ts.map

package/dist/src/generators/resource/resource.run.js

@@ -1,15 +1,35 @@
 /**
  * zudojs-cli — Running a resource-family schematic for `zudojs generate`.
  */
+import { join } from "node:path";
 import { describeError } from "../../commands/commandError.helper.js";
 import { CLIGenerationError, CLIValidationError } from "../../errors/index.js";
+import { detectPackageManager } from "../../resolvers/layout/projectLayout.core.js";
+import { execCommand } from "../../utils/utils.exec.js";
 import { generateResource } from "./resource.generator.js";
 import { resolveResourceLayout } from "./resource.layout.js";
 import { describeAddedDependencies, ensureZudojsDependencies, fileCount, } from "../../wiring/index.js";
+/** `<pm> exec prisma generate`, spelled the way each package manager wants it. */
+export function prismaGenerateCommand(packageManager) {
+    switch (packageManager) {
+        case "npm":
+            return ["npx", "prisma", "generate"];
+        case "yarn":
+            return ["yarn", "prisma", "generate"];
+        case "bun":
+            return ["bun", "run", "prisma", "generate"];
+        case "pnpm":
+        default:
+            return ["pnpm", "exec", "prisma", "generate"];
+    }
+}
 /**
  * Runs a resource-family schematic: writes the DTO → repository → service
  * → controller → routes chain it needs and registers the routes and the
- * controller between the project's markers.
+ * controller between the project's markers. When a model was appended to
+ * `prisma/schema.prisma`, runs `prisma generate` so the new Prisma-backed
+ * repository compiles at once (`prisma migrate dev` no longer regenerates
+ * the client); when that fails — nothing installed yet — it says what to run.
  */
 export async function runResourceSchematic(context, run) {
     const layout = resolveResourceLayout({
@@ -21,13 +41,7 @@ export async function runResourceSchematic(context, run) {
     });
     let result;
     try {
-        result = await generateResource({
-            name: run.name,
-            schematic: run.schematic,
-            layout,
-            dryRun: run.dryRun,
-            force: run.force,
-        }, run.cwd);
+        result = await generateResource({ name: run.name, schematic: run.schematic, layout, dryRun: run.dryRun, force: run.force }, run.cwd);
     }
     catch (error) {
         if (error instanceof CLIValidationError)
@@ -45,8 +59,18 @@ export async function runResourceSchematic(context, run) {
             context.logger.warn(line);
         }
     }
+    if (!run.dryRun && result.prismaSchema !== undefined) {
+        const [file, ...args] = prismaGenerateCommand(run.packageManager ?? detectPackageManager(run.cwd));
+        const command = [file, ...args].join(" ");
+        try {
+            await (run.exec ?? execCommand)(file, args, join(run.cwd, layout.appRoot));
+            context.logger.info(`Ran "${command}" for the model added to ${result.prismaSchema}.`);
+        }
+        catch (error) {
+            context.logger.warn(`Could not run "${command}" (${describeError(error)}). Run it after installing dependencies; until then the Prisma repository does not type-check.`);
+        }
+    }
     if (result.manualSteps.length > 0) {
         context.logger.warn(`Finish by hand:\n${result.manualSteps.map((step) => `  - ${step}`).join("\n")}`);
     }
 }
-//# sourceMappingURL=resource.run.js.map

package/dist/src/generators/validator/index.d.ts

@@ -2,4 +2,3 @@
  * zudojs-cli — Validator Generator
  */
 export { generateValidator, type GenerateValidatorOptions, } from "./validator.generator.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/generators/validator/index.js

@@ -2,4 +2,3 @@
  * zudojs-cli — Validator Generator
  */
 export { generateValidator, } from "./validator.generator.js";
-//# sourceMappingURL=index.js.map

package/dist/src/generators/validator/validator.generator.d.ts

@@ -1,12 +1,16 @@
 /**
  * zudojs-cli — Validator Generator
  *
- * Generates validator files.
+ * Writes `validators/<name>.validator.ts`: a @zudojs/schema object schema,
+ * its inferred type and a `validate<Name>(input)` that returns the schema's
+ * `SchemaResult` (data on success, issues on failure). It used to write
+ * `validate<Name>(input) { return true; }`, a stub that accepted everything.
  */
 export interface GenerateValidatorOptions {
     readonly name: string;
     readonly basePath: string;
     readonly dryRun?: boolean;
 }
+/** Renders the validator source for `name` (kebab-case) and its PascalCase form. */
+export declare function renderValidatorFile(name: string, pascal: string): string;
 export declare function generateValidator(options: GenerateValidatorOptions, cwd: string): Promise<string[]>;
-//# sourceMappingURL=validator.generator.d.ts.map

package/dist/src/generators/validator/validator.generator.js

@@ -1,22 +1,44 @@
 /**
  * zudojs-cli — Validator Generator
  *
- * Generates validator files.
+ * Writes `validators/<name>.validator.ts`: a @zudojs/schema object schema,
+ * its inferred type and a `validate<Name>(input)` that returns the schema's
+ * `SchemaResult` (data on success, issues on failure). It used to write
+ * `validate<Name>(input) { return true; }`, a stub that accepted everything.
  */
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
 import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
+/** Renders the validator source for `name` (kebab-case) and its PascalCase form. */
+export function renderValidatorFile(name, pascal) {
+    return `import { schema, type Infer, type SchemaResult } from "@zudojs/schema";
+
+/** Shape of a valid ${name}. Replace the fields with your own. */
+export const ${pascal}Schema = schema.object({
+  id: schema.string().min(1),
+});
+
+export type ${pascal} = Infer<typeof ${pascal}Schema>;
+
+/**
+ * Validates \`input\` against {@link ${pascal}Schema}. On failure the result
+ * carries the issues (path and message) instead of throwing:
+ *
+ * \`\`\`ts
+ * const result = validate${pascal}(body);
+ * if (!result.success) return validationFailed(result.issues);
+ * result.data; // a ${pascal}
+ * \`\`\`
+ */
+export function validate${pascal}(input: unknown): SchemaResult<${pascal}> {
+  return ${pascal}Schema.safeParse(input);
+}
+`;
+}
 export async function generateValidator(options, cwd) {
     const name = normalizeName(options.name);
     const namePascal = toPascalCase(options.name);
     const files = {
-        [`${options.basePath}/validators/${name}.validator.ts`]: `/**
- * ${name} validator.
- */
-
-export function validate${namePascal}(input: unknown): boolean {
-  return true;
-}
-`,
+        [`${options.basePath}/validators/${name}.validator.ts`]: renderValidatorFile(name, namePascal),
     };
     if (options.dryRun) {
         return Object.keys(files);
@@ -24,4 +46,3 @@ export function validate${namePascal}(input: unknown): boolean {
     await writeFileTree(cwd, files);
     return Object.keys(files);
 }
-//# sourceMappingURL=validator.generator.js.map

package/dist/src/index.d.ts

@@ -55,4 +55,3 @@ export { RollbackManager, type RollbackEntry, type RollbackFailure, type Rollbac
 export { ManifestManager, parseManifest, type ManifestReadResult, type ManifestReadStatus, type ZudojsManifest, } from "./manifest/index.js";
 export type { ProjectConfiguration, ProjectType, BackendArchitecture, FrontendFramework, FrontendArchitecture, DatabaseProvider, ApiStyle, PackageManagerType, } from "./types/projectConfiguration.type.js";
 export type { ScaffoldOptions, ArchitectureType, PackageManager, DatabaseEngine, ProjectTemplate, GenerateOptions, } from "./types/index.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -64,4 +64,3 @@ export { TaskRunner, } from "./runners/task/index.js";
 export { RollbackManager, } from "./rollback/index.js";
 // Manifest
 export { ManifestManager, parseManifest, } from "./manifest/index.js";
-//# sourceMappingURL=index.js.map

package/dist/src/installers/dependency.installer.d.ts

@@ -11,4 +11,3 @@ export declare function getAddCommand(packageManager: PackageManager, pkg: strin
  */
 export declare function getRunScriptCommand(packageManager: PackageManager, script: string): [string, ...string[]];
 export declare function installDependencies(packageManager: PackageManager, cwd: string): Promise<void>;
-//# sourceMappingURL=dependency.installer.d.ts.map

package/dist/src/installers/dependency.installer.js

@@ -52,4 +52,3 @@ export async function installDependencies(packageManager, cwd) {
     const [file, ...args] = getInstallCommand(packageManager);
     await runStreaming(file, args, cwd);
 }
-//# sourceMappingURL=dependency.installer.js.map

package/dist/src/installers/index.d.ts

@@ -2,4 +2,3 @@
  * zudojs-cli — Installers
  */
 export { getInstallCommand, getAddCommand, getRunScriptCommand, installDependencies, } from "./dependency.installer.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/installers/index.js

@@ -2,4 +2,3 @@
  * zudojs-cli — Installers
  */
 export { getInstallCommand, getAddCommand, getRunScriptCommand, installDependencies, } from "./dependency.installer.js";
-//# sourceMappingURL=index.js.map

package/dist/src/manifest/index.d.ts

@@ -5,4 +5,3 @@
  */
 export { ManifestManager, type ZudojsManifest, } from "./manifestManager.core.js";
 export { parseManifest, type ManifestReadResult, type ManifestReadStatus, } from "./manifestFile.helper.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/manifest/index.js

@@ -5,4 +5,3 @@
  */
 export { ManifestManager, } from "./manifestManager.core.js";
 export { parseManifest, } from "./manifestFile.helper.js";
-//# sourceMappingURL=index.js.map

package/dist/src/manifest/manifestFile.helper.d.ts

@@ -39,4 +39,3 @@ export declare function writeManifestFile(manifestPath: string, manifest: Zudojs
  * across processes.
  */
 export declare function withManifestLock<T>(manifestPath: string, operation: () => Promise<T>): Promise<T>;
-//# sourceMappingURL=manifestFile.helper.d.ts.map

package/dist/src/manifest/manifestFile.helper.js

@@ -138,4 +138,3 @@ async function isStale(lockPath) {
         return false;
     }
 }
-//# sourceMappingURL=manifestFile.helper.js.map

package/dist/src/manifest/manifestManager.core.d.ts

@@ -52,4 +52,3 @@ export declare class ManifestManager {
     private require;
     private write;
 }
-//# sourceMappingURL=manifestManager.core.d.ts.map

package/dist/src/manifest/manifestManager.core.js

@@ -90,4 +90,3 @@ export class ManifestManager {
         await writeManifestFile(this.manifestPath, manifest);
     }
 }
-//# sourceMappingURL=manifestManager.core.js.map

package/dist/src/prompts/backend/api-style.prompt.d.ts

@@ -5,4 +5,3 @@
  */
 import type { ApiStyle } from "../../types/projectConfiguration.type.js";
 export declare function promptApiStyle(overrides?: ApiStyle): Promise<ApiStyle>;
-//# sourceMappingURL=api-style.prompt.d.ts.map

package/dist/src/prompts/backend/api-style.prompt.js

@@ -30,4 +30,3 @@ export async function promptApiStyle(overrides) {
         }));
     return cancelled(value);
 }
-//# sourceMappingURL=api-style.prompt.js.map

package/dist/src/prompts/backend/backend-architecture.prompt.d.ts

@@ -5,4 +5,3 @@
  */
 import type { BackendArchitecture } from "../../types/projectConfiguration.type.js";
 export declare function promptBackendArchitecture(overrides?: BackendArchitecture): Promise<BackendArchitecture>;
-//# sourceMappingURL=backend-architecture.prompt.d.ts.map

package/dist/src/prompts/backend/backend-architecture.prompt.js

@@ -15,4 +15,3 @@ export async function promptBackendArchitecture(overrides) {
         }));
     return cancelled(value);
 }
-//# sourceMappingURL=backend-architecture.prompt.js.map

package/dist/src/prompts/backend/database.prompt.d.ts

@@ -5,4 +5,3 @@
  */
 import type { DatabaseProvider } from "../../types/projectConfiguration.type.js";
 export declare function promptDatabase(overrides?: DatabaseProvider): Promise<DatabaseProvider>;
-//# sourceMappingURL=database.prompt.d.ts.map

package/dist/src/prompts/backend/database.prompt.js

@@ -15,4 +15,3 @@ export async function promptDatabase(overrides) {
         }));
     return cancelled(value);
 }
-//# sourceMappingURL=database.prompt.js.map

package/dist/src/prompts/backend/index.d.ts

@@ -7,4 +7,3 @@ export { promptBackendArchitecture } from "./backend-architecture.prompt.js";
 export { promptDatabase } from "./database.prompt.js";
 export { promptApiStyle } from "./api-style.prompt.js";
 export { promptServices } from "./services.prompt.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/prompts/backend/index.js

@@ -7,4 +7,3 @@ export { promptBackendArchitecture } from "./backend-architecture.prompt.js";
 export { promptDatabase } from "./database.prompt.js";
 export { promptApiStyle } from "./api-style.prompt.js";
 export { promptServices } from "./services.prompt.js";
-//# sourceMappingURL=index.js.map

package/dist/src/prompts/backend/services.prompt.d.ts

@@ -4,4 +4,3 @@
  * Prompts for microservice service names (comma-separated).
  */
 export declare function promptServices(overrides?: readonly string[]): Promise<string[]>;
-//# sourceMappingURL=services.prompt.d.ts.map

package/dist/src/prompts/backend/services.prompt.js

@@ -38,4 +38,3 @@ export async function promptServices(overrides) {
     });
     return parseServices(cancelled(value));
 }
-//# sourceMappingURL=services.prompt.js.map

package/dist/src/prompts/cancel.prompt.d.ts

@@ -19,4 +19,3 @@
  * @returns The answer, once it is known not to be the cancel symbol.
  */
 export declare function cancelled<T>(value: T): Exclude<T, symbol>;
-//# sourceMappingURL=cancel.prompt.d.ts.map

package/dist/src/prompts/cancel.prompt.js

@@ -27,4 +27,3 @@ export function cancelled(value) {
     }
     return value;
 }
-//# sourceMappingURL=cancel.prompt.js.map

package/dist/src/prompts/capabilities/capabilities.prompt.d.ts

@@ -9,4 +9,3 @@ export interface CapabilityOption {
     readonly hint?: string;
 }
 export declare function promptCapabilities(selected?: readonly string[]): Promise<string[]>;
-//# sourceMappingURL=capabilities.prompt.d.ts.map

package/dist/src/prompts/capabilities/capabilities.prompt.js

@@ -40,4 +40,3 @@ export async function promptCapabilities(selected = []) {
     });
     return cancelled(value);
 }
-//# sourceMappingURL=capabilities.prompt.js.map

package/dist/src/prompts/capabilities/index.d.ts

@@ -4,4 +4,3 @@
  * Barrel exports for capabilities prompts.
  */
 export { promptCapabilities, type CapabilityOption, } from "./capabilities.prompt.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/prompts/capabilities/index.js

@@ -4,4 +4,3 @@
  * Barrel exports for capabilities prompts.
  */
 export { promptCapabilities, } from "./capabilities.prompt.js";
-//# sourceMappingURL=index.js.map

package/dist/src/prompts/frontend/framework.prompt.d.ts

@@ -5,4 +5,3 @@
  */
 import type { FrontendFramework } from "../../types/projectConfiguration.type.js";
 export declare function promptFramework(projectType: string, overrides?: FrontendFramework | "none"): Promise<FrontendFramework | "none">;
-//# sourceMappingURL=framework.prompt.d.ts.map

package/dist/src/prompts/frontend/framework.prompt.js

@@ -36,4 +36,3 @@ export async function promptFramework(projectType, overrides) {
         }));
     return cancelled(value);
 }
-//# sourceMappingURL=framework.prompt.js.map

package/dist/src/prompts/frontend/frontend-architecture.prompt.d.ts

@@ -5,4 +5,3 @@
  */
 import type { FrontendArchitecture } from "../../types/projectConfiguration.type.js";
 export declare function promptFrontendArchitecture(overrides?: FrontendArchitecture): Promise<FrontendArchitecture>;
-//# sourceMappingURL=frontend-architecture.prompt.d.ts.map

package/dist/src/prompts/frontend/frontend-architecture.prompt.js

@@ -35,4 +35,3 @@ export async function promptFrontendArchitecture(overrides) {
         }));
     return cancelled(value);
 }
-//# sourceMappingURL=frontend-architecture.prompt.js.map

package/dist/src/prompts/frontend/index.d.ts

@@ -5,4 +5,3 @@
  */
 export { promptFramework } from "./framework.prompt.js";
 export { promptFrontendArchitecture } from "./frontend-architecture.prompt.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/prompts/frontend/index.js

@@ -5,4 +5,3 @@
  */
 export { promptFramework } from "./framework.prompt.js";
 export { promptFrontendArchitecture } from "./frontend-architecture.prompt.js";
-//# sourceMappingURL=index.js.map

package/dist/src/prompts/index.d.ts

@@ -12,4 +12,3 @@ export { promptFramework } from "./frontend/framework.prompt.js";
 export { promptFrontendArchitecture } from "./frontend/frontend-architecture.prompt.js";
 export { promptPackageManager } from "./workspace/package-manager.prompt.js";
 export { promptCapabilities, type CapabilityOption, } from "./capabilities/capabilities.prompt.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/prompts/index.js

@@ -12,4 +12,3 @@ export { promptFramework } from "./frontend/framework.prompt.js";
 export { promptFrontendArchitecture } from "./frontend/frontend-architecture.prompt.js";
 export { promptPackageManager } from "./workspace/package-manager.prompt.js";
 export { promptCapabilities, } from "./capabilities/capabilities.prompt.js";
-//# sourceMappingURL=index.js.map