zudojs-cli 2.1.1 → 2.1.2

package/README.md

@@ -178,7 +178,7 @@ current directory.
 | Option            | Applies to                    | Description                                                        |
 | ----------------- | ----------------------------- | ------------------------------------------------------------------ |
 | `--module <name>` | every schematic but `module`  | Generates inside `<root>/modules/<name>` instead of the schematic's default directory |
-| `--service <name>`| microservice projects, CQRS   | Selects the app a schematic belongs to; also names the CQRS service for `command`/`query` |
+| `--service <name>`| microservice projects          | Selects the microservice app a schematic (including `command`/`query`) is written into |
 | `--dry-run`       | all                           | Lists the files without writing anything                           |
 | `--force`         | all                           | Overwrites files that already exist                                |
 

package/dist/src/bin/zudojs.js

@@ -178,7 +178,7 @@ app.register(createCommand({
         {
             name: "service",
             short: "s",
-            description: "The service name (for CQRS commands/queries)",
+            description: "Microservice projects: the app to generate into (gateway or a service name). Elsewhere: a folder grouping CQRS commands/queries",
             type: "string",
         },
         {

package/dist/src/commands/generate.command.js

@@ -6,7 +6,6 @@
  * backend lives, then places the schematic accordingly.
  */
 import { join } from "node:path";
-import { generateService } from "../generators/service/service.generator.js";
 import { generateModule } from "../generators/module/module.generator.js";
 import { generateCommand } from "../generators/command/command.generator.js";
 import { generateQuery } from "../generators/query/query.generator.js";
@@ -53,10 +52,6 @@ function getArchitectureRoot(architecture, schematic, serviceName) {
             }
             return "src";
         case "microservice":
-            if (schematic === "service") {
-                // A new service is a new app in the workspace.
-                return "apps/services";
-            }
             // `--service <name>` selects which app the schematic belongs to.
             // Without it the gateway app — the one app always generated — is used.
             // Modules go to that app's src/modules, next to the scaffolded ones,
@@ -72,13 +67,6 @@ function getArchitectureRoot(architecture, schematic, serviceName) {
             if (schematic === "module") {
                 return "src/modules";
             }
-            if (schematic === "service") {
-                // The monolith template scaffolds `src/services/app.service.ts` and a
-                // `src/services/index.ts` barrel. Generating into `src/<name>/`
-                // instead left two conventions in one project, and the generated
-                // service was never exported from the barrel the template owns.
-                return "src/services";
-            }
             return "src";
     }
 }
@@ -254,8 +242,6 @@ async function runSchematic(schematic, name, options, cwd) {
         // writing to `<basePath>/commands/<name>`.
         const cqrsService = options.architecture === "microservice" ? undefined : options.service;
         switch (schematic) {
-            case "service":
-                return await generateService({ name, basePath, dryRun }, cwd);
             case "module":
                 return await generateModule({ name, feature: true, basePath, dryRun, onRegistered: options.onModuleRegistered }, cwd);
             case "command":

package/dist/src/constants/index.js

@@ -133,7 +133,11 @@ export const SCHEMA_CHOICES = Object.freeze([
         label: "Resource",
         hint: "DTO, repository, service, controller, CRUD routes and a test, registered",
     },
-    { value: "service", label: "Service (CQRS)" },
+    {
+        value: "service",
+        label: "Service",
+        hint: "src/services/<name>.service.ts, plus its DTO and repository when missing",
+    },
     { value: "module", label: "Module" },
     { value: "command", label: "Command" },
     { value: "query", label: "Query" },

package/dist/src/constants/zudojsVersions.generated.js

@@ -6,43 +6,43 @@
  * Do not edit by hand; run `node scripts/generateZudojsVersions.mjs`.
  */
 export const ZUDOJS_PACKAGE_VERSIONS = Object.freeze({
-    "@zudojs/adapters": "1.2.1",
-    "@zudojs/api": "1.2.1",
-    "@zudojs/auth": "1.3.1",
-    "@zudojs/auth-oauth": "1.2.3",
-    "@zudojs/cache": "1.2.1",
-    "@zudojs/config": "1.3.1",
-    "@zudojs/constants": "1.1.2",
-    "@zudojs/container": "1.2.1",
-    "@zudojs/core": "1.2.2",
-    "@zudojs/cqrs": "1.2.1",
-    "@zudojs/crypto": "1.3.1",
-    "@zudojs/database": "1.3.1",
-    "@zudojs/docs": "1.0.4",
-    "@zudojs/errors": "1.3.0",
-    "@zudojs/events": "1.3.1",
-    "@zudojs/feature-flags": "1.4.0",
-    "@zudojs/http": "1.4.2",
-    "@zudojs/lifecycle": "1.2.1",
-    "@zudojs/logger": "1.4.1",
-    "@zudojs/messaging": "1.2.1",
-    "@zudojs/middleware": "1.1.0",
-    "@zudojs/observability": "1.2.1",
-    "@zudojs/openapi": "1.5.0",
-    "@zudojs/permissions": "1.4.1",
-    "@zudojs/plugins": "1.3.1",
-    "@zudojs/queue": "1.4.1",
-    "@zudojs/rpc": "1.4.1",
-    "@zudojs/runtime": "1.3.1",
-    "@zudojs/scheduler": "1.2.0",
-    "@zudojs/schema": "1.2.1",
-    "@zudojs/security": "1.3.1",
-    "@zudojs/serialization": "1.2.1",
-    "@zudojs/storage": "1.2.1",
-    "@zudojs/tenancy": "1.3.1",
-    "@zudojs/testing": "1.2.2",
-    "@zudojs/transactions": "1.2.0",
+    "@zudojs/adapters": "1.2.2",
+    "@zudojs/api": "1.2.2",
+    "@zudojs/auth": "1.3.2",
+    "@zudojs/auth-oauth": "1.2.4",
+    "@zudojs/cache": "1.2.2",
+    "@zudojs/config": "1.3.2",
+    "@zudojs/constants": "1.1.3",
+    "@zudojs/container": "1.2.2",
+    "@zudojs/core": "1.2.3",
+    "@zudojs/cqrs": "1.2.2",
+    "@zudojs/crypto": "1.3.2",
+    "@zudojs/database": "1.3.2",
+    "@zudojs/docs": "1.0.5",
+    "@zudojs/errors": "1.3.1",
+    "@zudojs/events": "1.3.2",
+    "@zudojs/feature-flags": "1.4.1",
+    "@zudojs/http": "1.4.3",
+    "@zudojs/lifecycle": "1.2.2",
+    "@zudojs/logger": "1.4.2",
+    "@zudojs/messaging": "1.2.2",
+    "@zudojs/middleware": "1.1.1",
+    "@zudojs/observability": "1.2.2",
+    "@zudojs/openapi": "1.5.1",
+    "@zudojs/permissions": "1.4.2",
+    "@zudojs/plugins": "1.3.2",
+    "@zudojs/queue": "1.5.0",
+    "@zudojs/rpc": "1.4.2",
+    "@zudojs/runtime": "1.3.2",
+    "@zudojs/scheduler": "1.2.1",
+    "@zudojs/schema": "1.2.2",
+    "@zudojs/security": "1.3.2",
+    "@zudojs/serialization": "1.2.2",
+    "@zudojs/storage": "1.2.2",
+    "@zudojs/tenancy": "1.3.2",
+    "@zudojs/testing": "1.2.3",
+    "@zudojs/transactions": "1.2.1",
     "@zudojs/types": "1.2.0",
-    "@zudojs/validation": "1.1.0",
+    "@zudojs/validation": "1.1.1",
 });
 //# sourceMappingURL=zudojsVersions.generated.js.map

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

@@ -1,13 +1,19 @@
 /**
  * zudojs-cli — Command Generator
  *
- * Generates a CQRS command with handler.
+ * Generates a CQRS command, its handler and a barrel under
+ * `<basePath>[/<service>]/commands/<name>/`.
  */
+/** Options for {@link generateCommand}. */
 export interface GenerateCommandOptions {
     readonly name: string;
     readonly service?: string;
     readonly basePath?: string;
     readonly dryRun?: boolean;
 }
+/**
+ * Writes `<name>.command.ts`, `<name>.handler.ts` and `index.ts`, and
+ * returns their paths (only the paths on a dry run).
+ */
 export declare function generateCommand(options: GenerateCommandOptions, cwd: string): Promise<string[]>;
 //# sourceMappingURL=command.generator.d.ts.map

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

@@ -1,55 +1,29 @@
 /**
  * zudojs-cli — Command Generator
  *
- * Generates a CQRS command with handler.
+ * Generates a CQRS command, its handler and a barrel under
+ * `<basePath>[/<service>]/commands/<name>/`.
  */
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
 import { CLIGenerationError } from "../../errors/index.js";
-import { normalizeName } from "../../utils/utils.name.js";
+import { assertGeneratableName } from "../../utils/utils.name.js";
+import { cqrsSchematicNames, renderCommandBarrel, renderCommandFile, renderCommandHandlerFile, } from "./command.template.js";
+/**
+ * Writes `<name>.command.ts`, `<name>.handler.ts` and `index.ts`, and
+ * returns their paths (only the paths on a dry run).
+ */
 export async function generateCommand(options, cwd) {
-    const name = normalizeName(options.name);
-    const nameCamel = name
-        .replace(/-([a-z])/g, (_m, c) => c.toUpperCase())
-        .replace(/^./, (c) => c.toUpperCase());
-    const service = options.service;
+    const names = cqrsSchematicNames(assertGeneratableName(options.name, "command name"));
     const basePath = options.basePath ?? "services";
-    // When no service grouping is given the schematic is written directly under
-    // basePath. Callers that resolved the owning app into basePath (the
-    // microservice layout) pass no service, so the path is not nested twice.
-    const servicePath = service ? `${basePath}/${service}` : basePath;
+    // Without a service group the schematic goes directly under basePath:
+    // callers that resolved the owning app into basePath (the microservice
+    // layout) pass no service, so the path is not nested twice.
+    const servicePath = options.service ? `${basePath}/${options.service}` : basePath;
+    const dir = `${servicePath}/commands/${names.slug}`;
     const files = {
-        [`${servicePath}/commands/${name}/${name}.command.ts`]: `import type { BaseCommand } from "@zudojs/cqrs";
-
-export interface ${nameCamel}CommandPayload {
-  readonly [key: string]: unknown;
-}
-
-export class ${nameCamel}Command implements BaseCommand<${nameCamel}CommandPayload> {
-  readonly commandName = "${name}";
-
-  constructor(public readonly payload: ${nameCamel}CommandPayload) {}
-}
-`,
-        [`${servicePath}/commands/${name}/${name}.handler.ts`]: `import type { CommandHandler, CommandResult } from "@zudojs/cqrs";
-import { createLogger } from "@zudojs/logger";
-import { ${nameCamel}Command } from "./${name}.command.js";
-
-export class ${nameCamel}CommandHandler implements CommandHandler<${nameCamel}Command> {
-  private readonly logger = createLogger({ name: "${name}-handler" });
-
-  async handle(command: ${nameCamel}Command): Promise<CommandResult> {
-    this.logger.info("Processing ${name} command", { payload: command.payload });
-
-    return {
-      success: true,
-      data: { id: crypto.randomUUID(), ...command.payload },
-    };
-  }
-}
-`,
-        [`${servicePath}/commands/${name}/index.ts`]: `export { ${nameCamel}Command } from "./${name}.command.js";
-export { ${nameCamel}CommandHandler } from "./${name}.handler.js";
-`,
+        [`${dir}/${names.slug}.command.ts`]: renderCommandFile(names),
+        [`${dir}/${names.slug}.handler.ts`]: renderCommandHandlerFile(names),
+        [`${dir}/index.ts`]: renderCommandBarrel(names),
     };
     if (options.dryRun) {
         return Object.keys(files);
@@ -59,7 +33,7 @@ export { ${nameCamel}CommandHandler } from "./${name}.handler.js";
         return Object.keys(files);
     }
     catch (error) {
-        throw new CLIGenerationError(`Failed to generate command: ${name} in ${servicePath}`, error);
+        throw new CLIGenerationError(`Failed to generate command: ${names.slug} in ${servicePath}`, error);
     }
 }
 //# sourceMappingURL=command.generator.js.map

package/dist/src/generators/command/command.template.d.ts

@@ -0,0 +1,24 @@
+/**
+ * zudojs-cli — Command schematic templates, written against the
+ * @zudojs/cqrs API: a `CommandOf` type built with `createCommand`, and a
+ * `CommandHandler` subclass (`commandType` + `execute`) registered on a
+ * `CommandBus`.
+ */
+/** Identifiers derived from a command name (`create-user`). */
+export interface CqrsSchematicNames {
+    /** kebab-case: folder and file names (`create-user`). */
+    readonly slug: string;
+    /** PascalCase: class and type prefix, and the bus discriminator (`CreateUser`). */
+    readonly pascal: string;
+    /** UPPER_SNAKE: prefix of the discriminator constant (`CREATE_USER`). */
+    readonly constant: string;
+}
+/** Derives {@link CqrsSchematicNames} from an already validated slug. */
+export declare function cqrsSchematicNames(slug: string): CqrsSchematicNames;
+/** `<slug>.command.ts`: the discriminator, payload, command type and factory. */
+export declare function renderCommandFile(n: CqrsSchematicNames): string;
+/** `<slug>.handler.ts`: the handler class and its bus registration. */
+export declare function renderCommandHandlerFile(n: CqrsSchematicNames): string;
+/** `index.ts`: the command folder's barrel. */
+export declare function renderCommandBarrel(n: CqrsSchematicNames): string;
+//# sourceMappingURL=command.template.d.ts.map

package/dist/src/generators/command/command.template.js

@@ -0,0 +1,78 @@
+/**
+ * zudojs-cli — Command schematic templates, written against the
+ * @zudojs/cqrs API: a `CommandOf` type built with `createCommand`, and a
+ * `CommandHandler` subclass (`commandType` + `execute`) registered on a
+ * `CommandBus`.
+ */
+import { toPascalCase } from "../../utils/utils.name.js";
+/** Derives {@link CqrsSchematicNames} from an already validated slug. */
+export function cqrsSchematicNames(slug) {
+    return { slug, pascal: toPascalCase(slug), constant: slug.toUpperCase().replace(/-/g, "_") };
+}
+/** `<slug>.command.ts`: the discriminator, payload, command type and factory. */
+export function renderCommandFile(n) {
+    const id = `${n.constant}_COMMAND`;
+    return `import { createCommand, type CommandOf } from "@zudojs/cqrs";
+
+/** Discriminator the command bus routes ${n.pascal} commands on. */
+export const ${id} = "${n.pascal}";
+
+/** Data a ${n.pascal} command carries. Replace it with the fields the use case needs. */
+export type ${n.pascal}CommandPayload = {
+  readonly data: Readonly<Record<string, unknown>>;
+};
+
+/** The ${n.pascal} command: \`{ type: "${n.pascal}", data }\`. */
+export type ${n.pascal}Command = CommandOf<typeof ${id}, ${n.pascal}CommandPayload>;
+
+/** Creates an immutable ${n.pascal} command. */
+export function create${n.pascal}Command(payload: ${n.pascal}CommandPayload): ${n.pascal}Command {
+  return createCommand(${id}, payload);
+}
+`;
+}
+/** `<slug>.handler.ts`: the handler class and its bus registration. */
+export function renderCommandHandlerFile(n) {
+    const id = `${n.constant}_COMMAND`;
+    return `import { randomUUID } from "node:crypto";
+
+import { CommandHandler, type CommandBus } from "@zudojs/cqrs";
+
+import { ${id}, type ${n.pascal}Command } from "./${n.slug}.command.js";
+
+/** What executing a ${n.pascal} command returns. */
+export interface ${n.pascal}CommandResult {
+  readonly id: string;
+  readonly data: Readonly<Record<string, unknown>>;
+}
+
+/** Handles ${n.pascal} commands: put the write-side logic in \`execute\`. */
+export class ${n.pascal}CommandHandler extends CommandHandler<${n.pascal}Command, ${n.pascal}CommandResult> {
+  public override readonly commandType = ${id};
+
+  public override async execute(command: ${n.pascal}Command): Promise<${n.pascal}CommandResult> {
+    return { id: randomUUID(), data: command.data };
+  }
+}
+
+/**
+ * Registers {@link ${n.pascal}CommandHandler} on a command bus.
+ *
+ * @example
+ * const bus = register${n.pascal}Command(createCommandBus());
+ * const result = await bus.execute<${n.pascal}Command, ${n.pascal}CommandResult>(
+ *   create${n.pascal}Command({ data: {} }),
+ * );
+ */
+export function register${n.pascal}Command(bus: CommandBus): CommandBus {
+  return bus.register(${id}, new ${n.pascal}CommandHandler());
+}
+`;
+}
+/** `index.ts`: the command folder's barrel. */
+export function renderCommandBarrel(n) {
+    return `export * from "./${n.slug}.command.js";
+export * from "./${n.slug}.handler.js";
+`;
+}
+//# sourceMappingURL=command.template.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — Command schematic: a `CommandOf` command type, its factory
+ * and a `CommandHandler` subclass for @zudojs/cqrs.
+ */
+export * from "./command.generator.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — Command schematic: a `CommandOf` command type, its factory
+ * and a `CommandHandler` subclass for @zudojs/cqrs.
+ */
+export * from "./command.generator.js";
+//# sourceMappingURL=index.js.map

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

@@ -8,7 +8,6 @@ export { FullstackComposer } from "./fullstack/index.js";
 export { IntegrationGenerator } from "./integration/index.js";
 export { InfrastructureGenerator } from "./infrastructure/index.js";
 export { generateModule } from "./module/module.generator.js";
-export { generateService } from "./service/service.generator.js";
 export { generateCommand } from "./command/command.generator.js";
 export { generateQuery } from "./query/query.generator.js";
 export { generateResource, resolveResourceLayout, planResource, RESOURCE_SCHEMATICS, } from "./resource/index.js";

package/dist/src/generators/index.js

@@ -8,7 +8,6 @@ export { FullstackComposer } from "./fullstack/index.js";
 export { IntegrationGenerator } from "./integration/index.js";
 export { InfrastructureGenerator } from "./infrastructure/index.js";
 export { generateModule } from "./module/module.generator.js";
-export { generateService } from "./service/service.generator.js";
 export { generateCommand } from "./command/command.generator.js";
 export { generateQuery } from "./query/query.generator.js";
 export { generateResource, resolveResourceLayout, planResource, RESOURCE_SCHEMATICS, } from "./resource/index.js";

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

@@ -7,7 +7,7 @@ import { writeFileTree } from "../../utils/utils.fileSystem.js";
 import { CLIValidationError } from "../../errors/index.js";
 import { resolveDatabaseAdapter } from "../../adapters/databases/databaseAdapter.resolver.js";
 import { resolveMicroserviceServices } from "../../templates/microservice/microservice.template.js";
-import { renderAppPackageDockerfile, renderWorkspaceAppDockerfile, } from "../../templates/shared/dockerfile.template.js";
+import { renderAppPackageDockerfile, renderWorkspaceAppDockerfile, } from "../../templates/shared/dockerfile/index.js";
 const SERVICE_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 /**
  * Database passwords are interpolated by compose from `.env`

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

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — Query schematic: a `QueryOf` query type, its factory and a
+ * `QueryHandler` subclass for @zudojs/cqrs.
+ */
+export * from "./query.generator.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — Query schematic: a `QueryOf` query type, its factory and a
+ * `QueryHandler` subclass for @zudojs/cqrs.
+ */
+export * from "./query.generator.js";
+//# sourceMappingURL=index.js.map

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

@@ -1,13 +1,19 @@
 /**
  * zudojs-cli — Query Generator
  *
- * Generates a CQRS query with handler.
+ * Generates a CQRS query, its handler and a barrel under
+ * `<basePath>[/<service>]/queries/<name>/`.
  */
+/** Options for {@link generateQuery}. */
 export interface GenerateQueryOptions {
     readonly name: string;
     readonly service?: string;
     readonly basePath?: string;
     readonly dryRun?: boolean;
 }
+/**
+ * Writes `<name>.query.ts`, `<name>.handler.ts` and `index.ts`, and returns
+ * their paths (only the paths on a dry run).
+ */
 export declare function generateQuery(options: GenerateQueryOptions, cwd: string): Promise<string[]>;
 //# sourceMappingURL=query.generator.d.ts.map

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

@@ -1,55 +1,30 @@
 /**
  * zudojs-cli — Query Generator
  *
- * Generates a CQRS query with handler.
+ * Generates a CQRS query, its handler and a barrel under
+ * `<basePath>[/<service>]/queries/<name>/`.
  */
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
 import { CLIGenerationError } from "../../errors/index.js";
-import { normalizeName } from "../../utils/utils.name.js";
+import { assertGeneratableName } from "../../utils/utils.name.js";
+import { cqrsSchematicNames } from "../command/command.template.js";
+import { renderQueryBarrel, renderQueryFile, renderQueryHandlerFile, } from "./query.template.js";
+/**
+ * Writes `<name>.query.ts`, `<name>.handler.ts` and `index.ts`, and returns
+ * their paths (only the paths on a dry run).
+ */
 export async function generateQuery(options, cwd) {
-    const name = normalizeName(options.name);
-    const nameCamel = name
-        .replace(/-([a-z])/g, (_m, c) => c.toUpperCase())
-        .replace(/^./, (c) => c.toUpperCase());
-    const service = options.service;
+    const names = cqrsSchematicNames(assertGeneratableName(options.name, "query name"));
     const basePath = options.basePath ?? "services";
-    // When no service grouping is given the schematic is written directly under
-    // basePath. Callers that resolved the owning app into basePath (the
-    // microservice layout) pass no service, so the path is not nested twice.
-    const servicePath = service ? `${basePath}/${service}` : basePath;
+    // Without a service group the schematic goes directly under basePath:
+    // callers that resolved the owning app into basePath (the microservice
+    // layout) pass no service, so the path is not nested twice.
+    const servicePath = options.service ? `${basePath}/${options.service}` : basePath;
+    const dir = `${servicePath}/queries/${names.slug}`;
     const files = {
-        [`${servicePath}/queries/${name}/${name}.query.ts`]: `import type { BaseQuery } from "@zudojs/cqrs";
-
-export interface ${nameCamel}QueryPayload {
-  readonly [key: string]: unknown;
-}
-
-export class ${nameCamel}Query implements BaseQuery<${nameCamel}QueryPayload> {
-  readonly queryName = "${name}";
-
-  constructor(public readonly payload: ${nameCamel}QueryPayload) {}
-}
-`,
-        [`${servicePath}/queries/${name}/${name}.handler.ts`]: `import type { QueryHandler, QueryResult } from "@zudojs/cqrs";
-import { createLogger } from "@zudojs/logger";
-import { ${nameCamel}Query } from "./${name}.query.js";
-
-export class ${nameCamel}QueryHandler implements QueryHandler<${nameCamel}Query> {
-  private readonly logger = createLogger({ name: "${name}-handler" });
-
-  async handle(query: ${nameCamel}Query): Promise<QueryResult> {
-    this.logger.info("Processing ${name} query", { payload: query.payload });
-
-    return {
-      success: true,
-      data: { items: [], total: 0 },
-    };
-  }
-}
-`,
-        [`${servicePath}/queries/${name}/index.ts`]: `export { ${nameCamel}Query } from "./${name}.query.js";
-export { ${nameCamel}QueryHandler } from "./${name}.handler.js";
-`,
+        [`${dir}/${names.slug}.query.ts`]: renderQueryFile(names),
+        [`${dir}/${names.slug}.handler.ts`]: renderQueryHandlerFile(names),
+        [`${dir}/index.ts`]: renderQueryBarrel(names),
     };
     if (options.dryRun) {
         return Object.keys(files);
@@ -59,7 +34,7 @@ export { ${nameCamel}QueryHandler } from "./${name}.handler.js";
         return Object.keys(files);
     }
     catch (error) {
-        throw new CLIGenerationError(`Failed to generate query: ${name} in ${servicePath}`, error);
+        throw new CLIGenerationError(`Failed to generate query: ${names.slug} in ${servicePath}`, error);
     }
 }
 //# sourceMappingURL=query.generator.js.map

package/dist/src/generators/query/query.template.d.ts

@@ -0,0 +1,14 @@
+/**
+ * zudojs-cli — Query schematic templates, written against the
+ * @zudojs/cqrs API: a `QueryOf` type built with `createQuery`, and a
+ * `QueryHandler` subclass (`queryType` + `execute`) registered on a
+ * `QueryBus`.
+ */
+import type { CqrsSchematicNames } from "../command/command.template.js";
+/** `<slug>.query.ts`: the discriminator, payload, query type and factory. */
+export declare function renderQueryFile(n: CqrsSchematicNames): string;
+/** `<slug>.handler.ts`: the handler class and its bus registration. */
+export declare function renderQueryHandlerFile(n: CqrsSchematicNames): string;
+/** `index.ts`: the query folder's barrel. */
+export declare function renderQueryBarrel(n: CqrsSchematicNames): string;
+//# sourceMappingURL=query.template.d.ts.map

package/dist/src/generators/query/query.template.js

@@ -0,0 +1,72 @@
+/**
+ * zudojs-cli — Query schematic templates, written against the
+ * @zudojs/cqrs API: a `QueryOf` type built with `createQuery`, and a
+ * `QueryHandler` subclass (`queryType` + `execute`) registered on a
+ * `QueryBus`.
+ */
+/** `<slug>.query.ts`: the discriminator, payload, query type and factory. */
+export function renderQueryFile(n) {
+    const id = `${n.constant}_QUERY`;
+    return `import { createQuery, type QueryOf } from "@zudojs/cqrs";
+
+/** Discriminator the query bus routes ${n.pascal} queries on. */
+export const ${id} = "${n.pascal}";
+
+/** Criteria a ${n.pascal} query carries. Replace it with the fields the read needs. */
+export type ${n.pascal}QueryPayload = {
+  readonly filter: Readonly<Record<string, unknown>>;
+};
+
+/** The ${n.pascal} query: \`{ type: "${n.pascal}", filter }\`. */
+export type ${n.pascal}Query = QueryOf<typeof ${id}, ${n.pascal}QueryPayload>;
+
+/** Creates an immutable ${n.pascal} query. */
+export function create${n.pascal}Query(payload: ${n.pascal}QueryPayload): ${n.pascal}Query {
+  return createQuery(${id}, payload);
+}
+`;
+}
+/** `<slug>.handler.ts`: the handler class and its bus registration. */
+export function renderQueryHandlerFile(n) {
+    const id = `${n.constant}_QUERY`;
+    return `import { QueryHandler, type QueryBus } from "@zudojs/cqrs";
+
+import { ${id}, type ${n.pascal}Query } from "./${n.slug}.query.js";
+
+/** What executing a ${n.pascal} query returns. */
+export interface ${n.pascal}QueryResult {
+  readonly filter: Readonly<Record<string, unknown>>;
+  readonly items: readonly unknown[];
+  readonly total: number;
+}
+
+/** Handles ${n.pascal} queries: put the read-side logic in \`execute\`. */
+export class ${n.pascal}QueryHandler extends QueryHandler<${n.pascal}Query, ${n.pascal}QueryResult> {
+  public override readonly queryType = ${id};
+
+  public override async execute(query: ${n.pascal}Query): Promise<${n.pascal}QueryResult> {
+    return { filter: query.filter, items: [], total: 0 };
+  }
+}
+
+/**
+ * Registers {@link ${n.pascal}QueryHandler} on a query bus.
+ *
+ * @example
+ * const bus = register${n.pascal}Query(createQueryBus());
+ * const result = await bus.execute<${n.pascal}Query, ${n.pascal}QueryResult>(
+ *   create${n.pascal}Query({ filter: {} }),
+ * );
+ */
+export function register${n.pascal}Query(bus: QueryBus): QueryBus {
+  return bus.register(${id}, new ${n.pascal}QueryHandler());
+}
+`;
+}
+/** `index.ts`: the query folder's barrel. */
+export function renderQueryBarrel(n) {
+    return `export * from "./${n.slug}.query.js";
+export * from "./${n.slug}.handler.js";
+`;
+}
+//# sourceMappingURL=query.template.js.map

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

@@ -1,16 +1,22 @@
 /**
  * zudojs-cli — Which files a resource-family schematic writes.
  *
- * `resource`, `route`, `controller`, `repository` and `dto` all write part
+ * `resource`, `route`, `controller`, `service`, `repository` and `dto` all write part
  * of the same DTO → repository → service → controller → routes chain. Each
  * writes its own layer ("primary") and any lower layer that does not exist
  * yet ("required"), so whatever it writes compiles on its own:
  * `generate controller users` also writes the users service, repository
  * and DTO when they are missing, and never touches them when they exist.
+ *
+ * `service` used to have a generator of its own that wrote
+ * `services/<name>/<name>.service.ts`, a second layout next to the
+ * `services/<name>.service.ts` every other schematic and the container
+ * wiring use; `generate controller` after `generate service` then wrote a
+ * second, unrelated service. It is part of the chain now.
  */
 import type { ResourceLayer } from "../../templates/resource/index.js";
 /** Schematics served by the resource generator. */
-export declare const RESOURCE_SCHEMATICS: readonly ["resource", "route", "controller", "repository", "dto"];
+export declare const RESOURCE_SCHEMATICS: readonly ["resource", "route", "controller", "service", "repository", "dto"];
 /** A schematic served by the resource generator. */
 export type ResourceSchematic = (typeof RESOURCE_SCHEMATICS)[number];
 /** Whether `schematic` is served by the resource generator. */

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

@@ -1,18 +1,25 @@
 /**
  * zudojs-cli — Which files a resource-family schematic writes.
  *
- * `resource`, `route`, `controller`, `repository` and `dto` all write part
+ * `resource`, `route`, `controller`, `service`, `repository` and `dto` all write part
  * of the same DTO → repository → service → controller → routes chain. Each
  * writes its own layer ("primary") and any lower layer that does not exist
  * yet ("required"), so whatever it writes compiles on its own:
  * `generate controller users` also writes the users service, repository
  * and DTO when they are missing, and never touches them when they exist.
+ *
+ * `service` used to have a generator of its own that wrote
+ * `services/<name>/<name>.service.ts`, a second layout next to the
+ * `services/<name>.service.ts` every other schematic and the container
+ * wiring use; `generate controller` after `generate service` then wrote a
+ * second, unrelated service. It is part of the chain now.
  */
 /** Schematics served by the resource generator. */
 export const RESOURCE_SCHEMATICS = [
     "resource",
     "route",
     "controller",
+    "service",
     "repository",
     "dto",
 ];
@@ -37,6 +44,8 @@ export function planResource(schematic) {
             };
         case "controller":
             return { primary: ["controller"], required: ["dto", "repository", "service"], register: false };
+        case "service":
+            return { primary: ["service"], required: ["dto", "repository"], register: false };
         case "repository":
             return { primary: ["repository"], required: ["dto"], register: false };
         case "dto":

package/dist/src/recipes/docker/docker.recipe.js

@@ -7,7 +7,7 @@
  */
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { renderAppPackageDockerfile } from "../../templates/shared/dockerfile.template.js";
+import { renderAppPackageDockerfile } from "../../templates/shared/dockerfile/index.js";
 import { renderComposeFile, usesPostgres } from "./docker.compose.js";
 const DOCKERIGNORE = `node_modules
 **/node_modules

package/dist/src/recipes/docker/docker.refresh.js

@@ -9,7 +9,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { renderAppPackageDockerfile } from "../../templates/shared/dockerfile.template.js";
+import { renderAppPackageDockerfile } from "../../templates/shared/dockerfile/index.js";
 import { writeFile } from "../../utils/utils.fileSystem.js";
 /** Rewrites unedited CLI Dockerfiles whose Prisma setting is stale; returns their paths. */
 export async function refreshGeneratedDockerfiles(context) {

package/dist/src/templates/resource/layers/resourceData.template.d.ts

@@ -1,7 +1,7 @@
 /**
  * zudojs-cli — A resource's DTO schemas and in-memory repository.
  */
-import type { ResourceNames } from "../resource.names.js";
+import { type ResourceNames } from "../resource.names.js";
 /** `dtos/<slug>.dto.ts`: @zudojs/schema schemas and their inferred types. */
 export declare function renderResourceDto(n: ResourceNames): string;
 /** `repositories/<slug>.repository.ts`: the contract and a memory store. */

package/dist/src/templates/resource/layers/resourceData.template.js

@@ -1,11 +1,12 @@
 /**
  * zudojs-cli — A resource's DTO schemas and in-memory repository.
  */
+import { withArticle } from "../resource.names.js";
 /** `dtos/<slug>.dto.ts`: @zudojs/schema schemas and their inferred types. */
 export function renderResourceDto(n) {
     return `import { schema, type Infer } from "@zudojs/schema";
 
-/** A ${n.label} as the API returns it. */
+/** ${withArticle(n.label, true)} as the API returns it. */
 export const ${n.entity}Schema = schema.object({
   id: schema.string().uuid(),
   name: schema.string(),

package/dist/src/templates/resource/layers/resourceRoutes.template.d.ts

@@ -1,7 +1,7 @@
 /**
  * zudojs-cli — A resource's CRUD routes (with OpenAPI metadata) and test.
  */
-import type { ResourceNames } from "../resource.names.js";
+import { type ResourceNames } from "../resource.names.js";
 /** `routes/<slug>.routes.ts`: `register<Pascal>Routes(router, controller)`. */
 export declare function renderResourceRoutes(n: ResourceNames): string;
 /**

package/dist/src/templates/resource/layers/resourceRoutes.template.js

@@ -1,6 +1,7 @@
 /**
  * zudojs-cli — A resource's CRUD routes (with OpenAPI metadata) and test.
  */
+import { withArticle } from "../resource.names.js";
 /** `routes/<slug>.routes.ts`: `register<Pascal>Routes(router, controller)`. */
 export function renderResourceRoutes(n) {
     const schemas = `Create${n.entity}Schema, ${n.entity}ParamsSchema, ${n.entity}Schema, Update${n.entity}Schema`;
@@ -30,7 +31,7 @@ export function register${n.pascal}Routes(
 
   router.get(\`\${BASE_PATH}/:id\`, controller.get, {
     openapi: {
-      summary: "Get a ${n.label}",
+      summary: "Get ${withArticle(n.label)}",
       tags: TAGS,
       params: ${n.entity}ParamsSchema,
       responses: { "200": { description: "The ${n.label}", schema: ${n.entity}Schema }, "400": invalid, "404": missing },
@@ -39,7 +40,7 @@ export function register${n.pascal}Routes(
 
   router.post(BASE_PATH, controller.create, {
     openapi: {
-      summary: "Create a ${n.label}",
+      summary: "Create ${withArticle(n.label)}",
       tags: TAGS,
       body: Create${n.entity}Schema,
       responses: { "201": { description: "Created", schema: ${n.entity}Schema }, "400": invalid },
@@ -48,7 +49,7 @@ export function register${n.pascal}Routes(
 
   router.patch(\`\${BASE_PATH}/:id\`, controller.update, {
     openapi: {
-      summary: "Update a ${n.label}",
+      summary: "Update ${withArticle(n.label)}",
       tags: TAGS,
       params: ${n.entity}ParamsSchema,
       body: Update${n.entity}Schema,
@@ -58,7 +59,7 @@ export function register${n.pascal}Routes(
 
   router.delete(\`\${BASE_PATH}/:id\`, controller.remove, {
     openapi: {
-      summary: "Delete a ${n.label}",
+      summary: "Delete ${withArticle(n.label)}",
       tags: TAGS,
       params: ${n.entity}ParamsSchema,
       responses: { "204": { description: "Deleted" }, "400": invalid, "404": missing },
@@ -92,7 +93,7 @@ const client = createHttpTestClient(router);
 afterAll(() => client.close());
 
 describe("${n.routePath}", () => {
-  it("creates, reads, updates and deletes a ${n.label}", async () => {
+  it("creates, reads, updates and deletes ${withArticle(n.label)}", async () => {
     const created = await client
       .post("${n.routePath}")
       .send({ name: "Ada" })

package/dist/src/templates/resource/resource.names.d.ts

@@ -35,4 +35,10 @@ export declare function singularize(slug: string): string;
  * @throws {CLIValidationError} For unusable or reserved names.
  */
 export declare function resourceNames(raw: string): ResourceNames;
+/**
+ * Prefixes `noun` with "a" or "an" by its (approximate) opening sound:
+ * `example` → "an example", `user` → "a user", `hour` → "an hour".
+ * Pass `capitalize` for the start of a sentence ("An example").
+ */
+export declare function withArticle(noun: string, capitalize?: boolean): string;
 //# sourceMappingURL=resource.names.d.ts.map

package/dist/src/templates/resource/resource.names.js

@@ -57,4 +57,19 @@ export function resourceNames(raw) {
         routePath: `/api/v1/${slug}`,
     };
 }
+/** Words spelled with a vowel but said with a consonant sound ("a user"). */
+const CONSONANT_SOUND = /^(u[bcdfghjklmnpqrstvwxyz][aeiou]|uu|eu|ewe|one|once)/;
+/** Words spelled with a consonant but said with a vowel sound ("an hour"). */
+const VOWEL_SOUND = /^(hour|honest|honor|honour|heir)/;
+/**
+ * Prefixes `noun` with "a" or "an" by its (approximate) opening sound:
+ * `example` → "an example", `user` → "a user", `hour` → "an hour".
+ * Pass `capitalize` for the start of a sentence ("An example").
+ */
+export function withArticle(noun, capitalize = false) {
+    const word = noun.toLowerCase();
+    const vowel = VOWEL_SOUND.test(word) || (/^[aeiou]/.test(word) && !CONSONANT_SOUND.test(word));
+    const article = vowel ? "an" : "a";
+    return `${capitalize ? article.charAt(0).toUpperCase() + article.slice(1) : article} ${noun}`;
+}
 //# sourceMappingURL=resource.names.js.map

package/dist/src/templates/shared/dockerfile/dockerfile.install.d.ts

@@ -0,0 +1,35 @@
+/**
+ * zudojs-cli — How a generated Dockerfile installs dependencies.
+ *
+ * A build stage used to copy only `package.json` and run a floating install
+ * (`npm install`), so two builds of the same commit could ship different
+ * dependency trees. When the lockfile describes the package being built, it
+ * is copied and installed frozen: `npm ci`, `pnpm install --frozen-lockfile`,
+ * `yarn install --immutable` (yarn 2+) or `--frozen-lockfile` (yarn 1), and
+ * `bun install --frozen-lockfile`.
+ *
+ * The lockfile is copied with a wildcard (`package-lock.json*`), which
+ * matches nothing rather than failing when there is none yet (a project
+ * created with `--skip-install`), and the install falls back to resolving
+ * from `package.json`, as the comment written above it says.
+ */
+/** The lockfile-related part of a Dockerfile build stage. */
+export interface DockerInstallSteps {
+    /** Comment lines, already prefixed with `# `. */
+    readonly comment: readonly string[];
+    /** Files copied next to `package.json` before the install (may be globs). */
+    readonly files: readonly string[];
+    /** The `RUN` command that installs dependencies. */
+    readonly install: string;
+    /** The `RUN` command that removes dev dependencies after the build. */
+    readonly prune?: string;
+}
+/** Install steps when the project's lockfile describes the package being built. */
+export declare function lockedInstallSteps(packageManager: string): DockerInstallSteps;
+/**
+ * Install steps for one app of a workspace, built on its own from its
+ * `package.json`. The workspace lockfile at the project root lists every
+ * package, so it cannot pin this app's isolated install.
+ */
+export declare function workspaceMemberInstallSteps(packageManager: string): DockerInstallSteps;
+//# sourceMappingURL=dockerfile.install.d.ts.map

package/dist/src/templates/shared/dockerfile/dockerfile.install.js

@@ -0,0 +1,89 @@
+/**
+ * zudojs-cli — How a generated Dockerfile installs dependencies.
+ *
+ * A build stage used to copy only `package.json` and run a floating install
+ * (`npm install`), so two builds of the same commit could ship different
+ * dependency trees. When the lockfile describes the package being built, it
+ * is copied and installed frozen: `npm ci`, `pnpm install --frozen-lockfile`,
+ * `yarn install --immutable` (yarn 2+) or `--frozen-lockfile` (yarn 1), and
+ * `bun install --frozen-lockfile`.
+ *
+ * The lockfile is copied with a wildcard (`package-lock.json*`), which
+ * matches nothing rather than failing when there is none yet (a project
+ * created with `--skip-install`), and the install falls back to resolving
+ * from `package.json`, as the comment written above it says.
+ */
+const FALLBACK = [
+    "# The lockfile is optional (copied with a wildcard): with it the install is",
+    "# frozen and the image reproducible; with no lockfile yet (nothing has been",
+    "# installed) dependencies resolve from package.json. Commit the lockfile.",
+];
+/** Install steps when the project's lockfile describes the package being built. */
+export function lockedInstallSteps(packageManager) {
+    switch (packageManager) {
+        case "pnpm":
+            return {
+                comment: FALLBACK,
+                // pnpm-workspace.yaml carries the build-script allow-list pnpm 11 needs.
+                files: ["pnpm-lock.yaml*", "pnpm-workspace.yaml"],
+                install: "corepack enable && if [ -f pnpm-lock.yaml ]; then pnpm install --frozen-lockfile; else pnpm install; fi",
+                prune: "pnpm prune --prod --ignore-scripts",
+            };
+        case "yarn":
+            return {
+                comment: [...FALLBACK, "# yarn 1 takes --frozen-lockfile; yarn 2+ takes --immutable."],
+                files: ["yarn.lock*", ".yarnrc.yml*"],
+                install: "corepack enable && if [ ! -f yarn.lock ]; then yarn install; " +
+                    "elif yarn --version | grep -q '^1\\.'; then yarn install --frozen-lockfile; " +
+                    "else yarn install --immutable; fi",
+            };
+        case "bun":
+            return {
+                comment: [...FALLBACK, "# The node image has no bun: it is installed from npm for the build."],
+                // bun.lock* matches bun.lock (bun 1.2+) and bun.lockb (older bun).
+                files: ["bun.lock*"],
+                install: "npm install -g bun && if [ -f bun.lock ] || [ -f bun.lockb ]; then bun install --frozen-lockfile; else bun install; fi",
+                // The first install wrote a lockfile if there was none, so this is frozen.
+                prune: "rm -rf node_modules && bun install --production --frozen-lockfile --ignore-scripts",
+            };
+        default:
+            return {
+                comment: FALLBACK,
+                files: ["package-lock.json*"],
+                install: "if [ -f package-lock.json ]; then npm ci; else npm install; fi",
+                prune: "npm prune --omit=dev --ignore-scripts",
+            };
+    }
+}
+/**
+ * Install steps for one app of a workspace, built on its own from its
+ * `package.json`. The workspace lockfile at the project root lists every
+ * package, so it cannot pin this app's isolated install.
+ */
+export function workspaceMemberInstallSteps(packageManager) {
+    const comment = [
+        "# This app is one package of a workspace and is installed on its own here.",
+        "# The workspace lockfile at the project root describes every package, so it",
+        "# cannot pin this install; dependencies resolve from package.json.",
+    ];
+    switch (packageManager) {
+        case "pnpm":
+            return {
+                comment,
+                files: ["pnpm-workspace.yaml"],
+                install: "corepack enable && pnpm install",
+                prune: "pnpm prune --prod --ignore-scripts",
+            };
+        case "yarn":
+            return { comment, files: [], install: "corepack enable && yarn install" };
+        default:
+            // The node image has no bun, so a bun workspace app installs with npm.
+            return {
+                comment,
+                files: [],
+                install: "npm install",
+                prune: "npm prune --omit=dev --ignore-scripts",
+            };
+    }
+}
+//# sourceMappingURL=dockerfile.install.js.map

package/dist/src/templates/shared/{dockerfile.template.d.ts → dockerfile/dockerfile.template.d.ts}

@@ -8,13 +8,15 @@
  * unprivileged `node` user and declares a /health HEALTHCHECK. The images
  * used to run as root and ship the whole dev toolchain.
  */
-/** The dependency install command for a package manager inside a Dockerfile. */
-export declare function dockerInstallCommand(packageManager: string): string;
 /**
  * A self-contained Dockerfile for one app package. The build context is the
  * project root; `appPath` is the app's directory (`.` for a single-app
  * project). pnpm's `pnpm-workspace.yaml` is copied for its build-script
  * allow-list, without which pnpm 11 refuses to install.
+ *
+ * An app at the project root copies its lockfile and installs frozen (see
+ * `dockerfile.install.ts`); an app inside a workspace cannot use the
+ * workspace lockfile on its own, and its Dockerfile says so.
  */
 export declare function renderAppPackageDockerfile(options: {
     readonly appPath: string;

package/dist/src/templates/shared/{dockerfile.template.js → dockerfile/dockerfile.template.js}

@@ -8,30 +8,7 @@
  * unprivileged `node` user and declares a /health HEALTHCHECK. The images
  * used to run as root and ship the whole dev toolchain.
  */
-/** The dependency install command for a package manager inside a Dockerfile. */
-export function dockerInstallCommand(packageManager) {
-    // No lockfile is generated, so never `npm ci`; bare node images need
-    // corepack for pnpm/yarn; bun is not available there, so npm is used.
-    switch (packageManager) {
-        case "pnpm":
-            return "corepack enable && pnpm install";
-        case "yarn":
-            return "corepack enable && yarn install";
-        default:
-            return "npm install";
-    }
-}
-/** Removes dev dependencies after the build (scripts off: prisma is a dev tool). */
-function dockerPruneCommand(packageManager) {
-    switch (packageManager) {
-        case "pnpm":
-            return "pnpm prune --prod --ignore-scripts";
-        case "yarn":
-            return undefined;
-        default:
-            return "npm prune --omit=dev --ignore-scripts";
-    }
-}
+import { lockedInstallSteps, workspaceMemberInstallSteps, } from "./dockerfile.install.js";
 function runnerFor(packageManager) {
     return packageManager === "npm" || packageManager === "bun" ? "npm" : packageManager;
 }
@@ -54,24 +31,31 @@ CMD ["node", "${dist}/server.js"]
  * project root; `appPath` is the app's directory (`.` for a single-app
  * project). pnpm's `pnpm-workspace.yaml` is copied for its build-script
  * allow-list, without which pnpm 11 refuses to install.
+ *
+ * An app at the project root copies its lockfile and installs frozen (see
+ * `dockerfile.install.ts`); an app inside a workspace cannot use the
+ * workspace lockfile on its own, and its Dockerfile says so.
  */
 export function renderAppPackageDockerfile(options) {
     const app = options.appPath.replace(/^\.\/?/, "").replace(/\/$/, "");
     const at = (file) => (app === "" ? file : `${app}/${file}`);
     const pm = options.packageManager;
-    const prune = dockerPruneCommand(pm);
+    const steps = app === "" ? lockedInstallSteps(pm) : workspaceMemberInstallSteps(pm);
+    const manifests = app === ""
+        ? [`COPY ${["package.json", ...steps.files].join(" ")} ./`]
+        : [`COPY ${at("package.json")} ./`, ...steps.files.map((file) => `COPY ${file} ./`)];
     const lines = [
         "# syntax=docker/dockerfile:1",
         "FROM node:24-alpine AS build",
         "WORKDIR /app",
-        `COPY ${at("package.json")} ./`,
-        ...(pm === "pnpm" ? ["COPY pnpm-workspace.yaml ./"] : []),
+        ...steps.comment,
+        ...manifests,
         ...(options.prisma ? [`COPY ${at("prisma.config.ts")} ./`, `COPY ${at("prisma")} ./prisma`] : []),
-        `RUN ${dockerInstallCommand(pm)}`,
+        `RUN ${steps.install}`,
         `COPY ${at("tsconfig.json")} ./`,
         `COPY ${at("src")} ./src`,
         `RUN ${runnerFor(pm)} run build`,
-        ...(prune === undefined ? [] : [`RUN ${prune}`]),
+        ...(steps.prune === undefined ? [] : [`RUN ${steps.prune}`]),
         "",
     ];
     return `${lines.join("\n")}\n${runtimeStage(options.port, "dist", "/app")}`;
@@ -86,13 +70,16 @@ export function renderWorkspaceAppDockerfile(options) {
     const runner = runnerFor(options.packageManager);
     const build = dir === "" ? `${runner} run build` : `cd ${dir} && ${runner} run build`;
     const dist = dir === "" ? "dist" : `${dir}/dist`;
+    // The whole workspace is copied, lockfile included, so it installs frozen.
+    const steps = lockedInstallSteps(options.packageManager);
     // pnpm links workspace dependencies through the root node_modules, so
     // the runtime stage takes the whole built workspace.
     return `# syntax=docker/dockerfile:1
 FROM node:24-alpine AS build
 WORKDIR /app
+${steps.comment.join("\n")}
 COPY . .
-RUN ${dockerInstallCommand(options.packageManager)}
+RUN ${steps.install}
 RUN ${build}
 
 FROM node:24-alpine AS runtime

package/dist/src/templates/shared/dockerfile/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — Generated Dockerfiles and how they install dependencies.
+ */
+export * from "./dockerfile.template.js";
+export * from "./dockerfile.install.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/templates/shared/dockerfile/index.js

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — Generated Dockerfiles and how they install dependencies.
+ */
+export * from "./dockerfile.template.js";
+export * from "./dockerfile.install.js";
+//# sourceMappingURL=index.js.map

package/dist/src/templates/shared/index.d.ts

@@ -3,7 +3,7 @@
  */
 export * from "./appRuntime.template.js";
 export * from "./capability.template.js";
-export * from "./dockerfile.template.js";
+export * from "./dockerfile/index.js";
 export * from "./pnpm.template.js";
 export * from "./server.template.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/templates/shared/index.js

@@ -3,7 +3,7 @@
  */
 export * from "./appRuntime.template.js";
 export * from "./capability.template.js";
-export * from "./dockerfile.template.js";
+export * from "./dockerfile/index.js";
 export * from "./pnpm.template.js";
 export * from "./server.template.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zudojs-cli",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Command-line interface for scaffolding, generating, and managing Zudojs framework projects.",
   "license": "MIT",
   "author": {
@@ -32,14 +32,14 @@
   ],
   "dependencies": {
     "@clack/prompts": "^1.8.1",
-    "@zudojs/config": "1.3.1",
-    "@zudojs/core": "1.2.2",
-    "@zudojs/errors": "1.3.0",
-    "@zudojs/logger": "1.4.1"
+    "@zudojs/config": "1.3.2",
+    "@zudojs/core": "1.2.3",
+    "@zudojs/errors": "1.3.1",
+    "@zudojs/logger": "1.4.2"
   },
   "devDependencies": {
     "@types/node": "^26.6.2",
-    "@zudojs/constants": "1.1.2",
+    "@zudojs/constants": "1.1.3",
     "tsx": "^4.23.15",
     "typescript": "7.0.2",
     "vitest": "^5.0.1"

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

@@ -1,12 +0,0 @@
-/**
- * zudojs-cli — Service Generator
- *
- * Generates a new service with CQRS structure.
- */
-export interface GenerateServiceOptions {
-    readonly name: string;
-    readonly basePath?: string;
-    readonly dryRun?: boolean;
-}
-export declare function generateService(options: GenerateServiceOptions, cwd: string): Promise<string[]>;
-//# sourceMappingURL=service.generator.d.ts.map

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

@@ -1,41 +0,0 @@
-/**
- * zudojs-cli — Service Generator
- *
- * Generates a new service with CQRS structure.
- */
-import { writeFileTree, mergeBarrelExport, } from "../../utils/utils.fileSystem.js";
-import { CLIGenerationError } from "../../errors/index.js";
-import { assertGeneratableName, toPascalCase } from "../../utils/utils.name.js";
-export async function generateService(options, cwd) {
-    const basePath = options.basePath ?? "services";
-    const name = assertGeneratableName(options.name, "service name");
-    const namePascal = toPascalCase(name);
-    const files = {
-        [`${basePath}/${name}/${name}.service.ts`]: `import { createLogger } from "@zudojs/logger";
-
-export class ${namePascal}Service {
-  private readonly logger = createLogger({ name: "${name}-service" });
-
-  async initialize(): Promise<void> {
-    this.logger.info("${name} service initialized");
-  }
-}
-`,
-        // Merge with any existing barrel content instead of overwriting it.
-        [`${basePath}/${name}/index.ts`]: mergeBarrelExport(cwd, `${basePath}/${name}/index.ts`, `export { ${namePascal}Service } from "./${name}.service.js";`),
-        // Preserve any existing content in the CQRS barrels.
-        [`${basePath}/${name}/commands/index.ts`]: mergeBarrelExport(cwd, `${basePath}/${name}/commands/index.ts`, ""),
-        [`${basePath}/${name}/queries/index.ts`]: mergeBarrelExport(cwd, `${basePath}/${name}/queries/index.ts`, ""),
-    };
-    if (options.dryRun) {
-        return Object.keys(files);
-    }
-    try {
-        await writeFileTree(cwd, files);
-        return Object.keys(files);
-    }
-    catch (error) {
-        throw new CLIGenerationError(`Failed to generate service: ${name}`, error);
-    }
-}
-//# sourceMappingURL=service.generator.js.map