zudojs-cli 2.1.1 → 2.1.3

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

@@ -0,0 +1,35 @@
+/**
+ * zudojs-cli — Generated `<name>.middleware.ts`.
+ *
+ * `generate middleware` used to write
+ * `(ctx: unknown, next: () => Promise<void>) => Promise<void>`: registering
+ * it in the server pipeline failed tsc with TS2322, and because it returned
+ * nothing the response produced by `next()` was dropped. The file is now a
+ * real `HttpMiddleware` from @zudojs/http that returns `next()`'s response.
+ */
+/** Renders the middleware source file. */
+export function renderMiddlewareFile(options) {
+    return `import type { HttpMiddleware } from "@zudojs/http";
+
+/**
+ * ${options.name} middleware.
+ *
+ * It runs when \`${options.factoryName}()\` is in the \`middlewares\` list of
+ * ${options.serverFile}, between the \`// zudojs:server-middleware\` markers:
+ * after the security headers, CORS and rate limit, before routing.
+ * \`zudojs generate middleware\` adds it there when the markers exist.
+ *
+ * To answer without calling \`next()\`, return a response such as
+ * \`createResponseContext({ status: 403 }).json({ error: "Forbidden" })\`.
+ * Otherwise return what \`next()\` resolves to, and \`clone()\` it before
+ * changing its headers.
+ */
+export function ${options.factoryName}(): HttpMiddleware {
+  return async (_context, next) => {
+    const response = await next();
+    return response;
+  };
+}
+`;
+}
+//# sourceMappingURL=middleware.template.js.map

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;