zudojs-cli 2.1.2 → 2.2.0

package/dist/src/templates/resource/layers/resourceHttp/resourceController.template.js

@@ -0,0 +1,55 @@
+/**
+ * zudojs-cli — A resource's controller.
+ */
+/**
+ * `controllers/<slug>.controller.ts`: validates input with the DTO schemas
+ * and maps service results to responses. Handlers are arrow properties so
+ * they can be passed to the router unbound.
+ */
+export function renderResourceController(n, appSrcFromControllers) {
+    const schemas = `Create${n.entity}Schema, List${n.pascal}QuerySchema, ${n.entity}ParamsSchema, Update${n.entity}Schema`;
+    return `import type { HttpResponseContext, HttpRouterContext } from "@zudojs/http";
+
+import { ${schemas} } from "../dtos/${n.slug}.dto.js";
+import type { ${n.pascal}Service } from "../services/${n.slug}.service.js";
+import { empty, json, readJsonBody, validationFailed } from "${appSrcFromControllers}/utils/http.js";
+
+/** HTTP handlers for ${n.routePath}. */
+export class ${n.pascal}Controller {
+  public constructor(private readonly service: ${n.pascal}Service) {}
+
+  public readonly list = async (ctx: HttpRouterContext): Promise<HttpResponseContext> => {
+    const query = List${n.pascal}QuerySchema.safeParse(ctx.query);
+    if (!query.success) return validationFailed(query.issues);
+    return json(200, await this.service.list(query.data));
+  };
+
+  public readonly get = async (ctx: HttpRouterContext): Promise<HttpResponseContext> => {
+    const params = ${n.entity}ParamsSchema.safeParse(ctx.params);
+    if (!params.success) return validationFailed(params.issues);
+    return json(200, await this.service.get(params.data.id));
+  };
+
+  public readonly create = async (ctx: HttpRouterContext): Promise<HttpResponseContext> => {
+    const body = Create${n.entity}Schema.safeParse(readJsonBody(ctx));
+    if (!body.success) return validationFailed(body.issues);
+    return json(201, await this.service.create(body.data));
+  };
+
+  public readonly update = async (ctx: HttpRouterContext): Promise<HttpResponseContext> => {
+    const params = ${n.entity}ParamsSchema.safeParse(ctx.params);
+    if (!params.success) return validationFailed(params.issues);
+    const body = Update${n.entity}Schema.safeParse(readJsonBody(ctx));
+    if (!body.success) return validationFailed(body.issues);
+    return json(200, await this.service.update(params.data.id, body.data));
+  };
+
+  public readonly remove = async (ctx: HttpRouterContext): Promise<HttpResponseContext> => {
+    const params = ${n.entity}ParamsSchema.safeParse(ctx.params);
+    if (!params.success) return validationFailed(params.issues);
+    await this.service.remove(params.data.id);
+    return empty(204);
+  };
+}
+`;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — A resource's CRUD routes, with OpenAPI metadata.
+ */
+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/resourceHttp/resourceRoutes.template.js

@@ -0,0 +1,77 @@
+/**
+ * zudojs-cli — A resource's CRUD routes, with OpenAPI metadata.
+ */
+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`,
+        `List${n.pascal}QuerySchema`,
+        `${n.entity}PageSchema`,
+        `${n.entity}ParamsSchema`,
+        `${n.entity}Schema`,
+        `Update${n.entity}Schema`,
+    ].join(", ");
+    return `import type { HttpRouter } from "@zudojs/http";
+
+import type { ${n.pascal}Controller } from "../controllers/${n.slug}.controller.js";
+import { ${schemas} } from "../dtos/${n.slug}.dto.js";
+
+const BASE_PATH = "${n.routePath}";
+const TAGS = ["${n.slug}"];
+const invalid = { description: "The request failed validation" };
+const missing = { description: "No ${n.label} has this id" };
+
+/** Registers the ${n.slug} CRUD routes. */
+export function register${n.pascal}Routes(
+  router: HttpRouter,
+  controller: ${n.pascal}Controller,
+): void {
+  router.get(BASE_PATH, controller.list, {
+    openapi: {
+      summary: "List ${n.slug}",
+      tags: TAGS,
+      query: List${n.pascal}QuerySchema,
+      responses: { "200": { description: "A page of ${n.label} records", schema: ${n.entity}PageSchema }, "400": invalid },
+    },
+  });
+
+  router.get(\`\${BASE_PATH}/:id\`, controller.get, {
+    openapi: {
+      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 },
+    },
+  });
+
+  router.post(BASE_PATH, controller.create, {
+    openapi: {
+      summary: "Create ${withArticle(n.label)}",
+      tags: TAGS,
+      body: Create${n.entity}Schema,
+      responses: { "201": { description: "Created", schema: ${n.entity}Schema }, "400": invalid },
+    },
+  });
+
+  router.patch(\`\${BASE_PATH}/:id\`, controller.update, {
+    openapi: {
+      summary: "Update ${withArticle(n.label)}",
+      tags: TAGS,
+      params: ${n.entity}ParamsSchema,
+      body: Update${n.entity}Schema,
+      responses: { "200": { description: "Updated", schema: ${n.entity}Schema }, "400": invalid, "404": missing },
+    },
+  });
+
+  router.delete(\`\${BASE_PATH}/:id\`, controller.remove, {
+    openapi: {
+      summary: "Delete ${withArticle(n.label)}",
+      tags: TAGS,
+      params: ${n.entity}ParamsSchema,
+      responses: { "204": { description: "Deleted" }, "400": invalid, "404": missing },
+    },
+  });
+}
+`;
+}

package/dist/src/templates/resource/layers/resourceHttp/resourceTest.template.d.ts

@@ -0,0 +1,11 @@
+/**
+ * zudojs-cli — A resource's HTTP test.
+ */
+import { type ResourceNames } from "../../resource.names.js";
+/**
+ * `tests/<slug>.test.ts` (or `tests/modules/<module>/<slug>.test.ts` for a
+ * module resource): drives the routes over real HTTP with
+ * `createHttpTestClient`, backed by the in-memory repository.
+ * `baseFromTests` is the import prefix from the test's folder to the layers.
+ */
+export declare function renderResourceTest(n: ResourceNames, baseFromTests: string): string;

package/dist/src/templates/resource/layers/resourceHttp/resourceTest.template.js

@@ -0,0 +1,84 @@
+/**
+ * zudojs-cli — A resource's HTTP test.
+ */
+import { withArticle } from "../../resource.names.js";
+/**
+ * `tests/<slug>.test.ts` (or `tests/modules/<module>/<slug>.test.ts` for a
+ * module resource): drives the routes over real HTTP with
+ * `createHttpTestClient`, backed by the in-memory repository.
+ * `baseFromTests` is the import prefix from the test's folder to the layers.
+ */
+export function renderResourceTest(n, baseFromTests) {
+    const b = baseFromTests;
+    return `import { afterAll, describe, expect, it } from "vitest";
+import { createRouter } from "@zudojs/http";
+import { createHttpTestClient } from "@zudojs/testing";
+
+import { ${n.pascal}Controller } from "${b}/controllers/${n.slug}.controller.js";
+import type { ${n.entity}Page } from "${b}/dtos/${n.slug}.dto.js";
+import { InMemory${n.pascal}Repository } from "${b}/repositories/${n.slug}.repository.js";
+import { register${n.pascal}Routes } from "${b}/routes/${n.slug}.routes.js";
+import { ${n.pascal}Service } from "${b}/services/${n.slug}.service.js";
+
+const router = createRouter();
+register${n.pascal}Routes(
+  router,
+  new ${n.pascal}Controller(new ${n.pascal}Service(new InMemory${n.pascal}Repository())),
+);
+const client = createHttpTestClient(router);
+afterAll(() => client.close());
+
+describe("${n.routePath}", () => {
+  it("creates, reads, updates and deletes ${withArticle(n.label)}", async () => {
+    const created = await client
+      .post("${n.routePath}")
+      .send({ name: "Ada" })
+      .expect(201)
+      .expectJson({ name: "Ada" });
+    const { id } = created.json<{ id: string }>();
+
+    await client.get(\`${n.routePath}/\${id}\`).expect(200).expectJson({ id, name: "Ada" });
+    await client
+      .patch(\`${n.routePath}/\${id}\`)
+      .send({ name: "Grace" })
+      .expect(200)
+      .expectJson({ name: "Grace" });
+    await client.delete(\`${n.routePath}/\${id}\`).expect(204);
+    await client.get(\`${n.routePath}/\${id}\`).expect(404);
+  });
+
+  it("lists ${n.label} records a page at a time", async () => {
+    const ids: string[] = [];
+    for (const name of ["Ada", "Grace", "Linus"]) {
+      const created = await client.post("${n.routePath}").send({ name }).expect(201);
+      ids.push(created.json<{ id: string }>().id);
+    }
+
+    const seen: string[] = [];
+    let cursor: string | null = null;
+    do {
+      const query: string = cursor === null ? "?limit=2" : \`?limit=2&cursor=\${cursor}\`;
+      const page: ${n.entity}Page = (await client.get(\`${n.routePath}\${query}\`).expect(200)).json<${n.entity}Page>();
+      expect(page.items.length).toBeLessThanOrEqual(2);
+      seen.push(...page.items.map((item) => item.id));
+      cursor = page.nextCursor;
+    } while (cursor !== null);
+    expect(seen).toEqual(expect.arrayContaining(ids));
+
+    await client.get("${n.routePath}?limit=0").expect(400);
+  });
+
+  it("rejects an invalid body with 400", async () => {
+    await client
+      .post("${n.routePath}")
+      .send({ name: "" })
+      .expect(400)
+      .expectJson({ error: "Validation failed" });
+  });
+
+  it("rejects an id that is not a UUID with 400", async () => {
+    await client.get("${n.routePath}/not-a-uuid").expect(400);
+  });
+});
+`;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — A resource's repository contract and in-memory store.
+ */
+import type { ResourceNames } from "../resource.names.js";
+/** `repositories/<slug>.repository.ts`: the contract and a memory store. */
+export declare function renderResourceRepository(n: ResourceNames): string;

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

@@ -0,0 +1,87 @@
+/**
+ * zudojs-cli — A resource's repository contract and in-memory store.
+ */
+/** `repositories/<slug>.repository.ts`: the contract and a memory store. */
+export function renderResourceRepository(n) {
+    const types = `Create${n.entity}Input, ${n.entity}, ${n.entity}Page, ${n.entity}PageRequest, Update${n.entity}Input`;
+    return `import { randomUUID } from "node:crypto";
+
+import { ConflictError } from "@zudojs/errors";
+
+import type { ${types} } from "../dtos/${n.slug}.dto.js";
+
+/** Storage contract for ${n.label} records; the service depends on this only. */
+export interface ${n.pascal}Repository {
+  /** One page in creation order, continuing after \`cursor\` when given. */
+  list(page: ${n.entity}PageRequest): Promise<${n.entity}Page>;
+  findById(id: string): Promise<${n.entity} | undefined>;
+  create(input: Create${n.entity}Input): Promise<${n.entity}>;
+  update(id: string, input: Update${n.entity}Input): Promise<${n.entity} | undefined>;
+  delete(id: string): Promise<boolean>;
+}
+
+/** Most records the in-memory store keeps, so it cannot exhaust memory. */
+const MAX_RECORDS = 10_000;
+
+/**
+ * Keeps ${n.label} records in process memory: for development and tests.
+ * Data is lost on restart. Swap the implementation in container.ts.
+ */
+export class InMemory${n.pascal}Repository implements ${n.pascal}Repository {
+  private readonly records = new Map<string, ${n.entity}>();
+
+  public async list(page: ${n.entity}PageRequest): Promise<${n.entity}Page> {
+    // A Map iterates in insertion order, which is creation order here.
+    const all = [...this.records.values()];
+    let start = 0;
+    if (page.cursor !== undefined) {
+      const at = all.findIndex((record) => record.id === page.cursor);
+      if (at === -1) return { items: [], nextCursor: null };
+      start = at + 1;
+    }
+    const items = all.slice(start, start + page.limit);
+    const last = items.at(-1);
+    const nextCursor = last !== undefined && start + page.limit < all.length ? last.id : null;
+    return { items, nextCursor };
+  }
+
+  public async findById(id: string): Promise<${n.entity} | undefined> {
+    return this.records.get(id);
+  }
+
+  public async create(input: Create${n.entity}Input): Promise<${n.entity}> {
+    if (this.records.size >= MAX_RECORDS) {
+      throw new ConflictError("The in-memory ${n.label} store is full.");
+    }
+    const now = new Date().toISOString();
+    const record: ${n.entity} = {
+      id: randomUUID(),
+      name: input.name,
+      createdAt: now,
+      updatedAt: now,
+    };
+    this.records.set(record.id, record);
+    return record;
+  }
+
+  public async update(
+    id: string,
+    input: Update${n.entity}Input,
+  ): Promise<${n.entity} | undefined> {
+    const existing = this.records.get(id);
+    if (existing === undefined) return undefined;
+    const updated: ${n.entity} = {
+      ...existing,
+      name: input.name ?? existing.name,
+      updatedAt: new Date().toISOString(),
+    };
+    this.records.set(id, updated);
+    return updated;
+  }
+
+  public async delete(id: string): Promise<boolean> {
+    return this.records.delete(id);
+  }
+}
+`;
+}

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

@@ -12,4 +12,3 @@ export declare function renderPrismaRepository(n: ResourceNames, appSrcFromRepos
 export declare function renderPrismaModel(n: ResourceNames): string;
 /** Whether `schema` already declares a model named `entity`. */
 export declare function hasPrismaModel(schema: string, entity: string): boolean;
-//# sourceMappingURL=resourcePrisma.template.d.ts.map

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

@@ -7,7 +7,7 @@
  */
 /** `repositories/<slug>.prisma.repository.ts`. */
 export function renderPrismaRepository(n, appSrcFromRepositories) {
-    const types = `Create${n.entity}Input, ${n.entity}, Update${n.entity}Input`;
+    const types = `Create${n.entity}Input, ${n.entity}, ${n.entity}Page, ${n.entity}PageRequest, Update${n.entity}Input`;
     const delegate = `prisma().${n.entityCamel}`;
     return `import { prisma } from "${appSrcFromRepositories}/integrations/database.js";
 import type { ${types} } from "../dtos/${n.slug}.dto.js";
@@ -29,17 +29,19 @@ function to${n.entity}(row: ${n.entity}Row): ${n.entity} {
   };
 }
 
-/** Most rows \`findAll\` returns; add pagination before raising it. */
-const LIST_LIMIT = 1000;
-
 /** Stores ${n.label} records in the \`${n.slug.replace(/-/g, "_")}\` table through Prisma. */
 export class Prisma${n.pascal}Repository implements ${n.pascal}Repository {
-  public async findAll(): Promise<readonly ${n.entity}[]> {
+  public async list(page: ${n.entity}PageRequest): Promise<${n.entity}Page> {
+    // Keyset pagination: one row more than asked tells whether a next page
+    // exists; \`cursor\` names the last row seen and \`skip: 1\` steps past it.
     const rows = await ${delegate}.findMany({
-      orderBy: { createdAt: "asc" },
-      take: LIST_LIMIT,
+      orderBy: [{ createdAt: "asc" }, { id: "asc" }],
+      take: page.limit + 1,
+      ...(page.cursor === undefined ? {} : { cursor: { id: page.cursor }, skip: 1 }),
     });
-    return rows.map(to${n.entity});
+    const items = rows.slice(0, page.limit).map(to${n.entity});
+    const last = items.at(-1);
+    return { items, nextCursor: rows.length > page.limit && last !== undefined ? last.id : null };
   }
 
   public async findById(id: string): Promise<${n.entity} | undefined> {
@@ -86,4 +88,3 @@ model ${n.entity} {
 export function hasPrismaModel(schema, entity) {
     return new RegExp(`^model\\s+${entity}\\s*\\{`, "m").test(schema);
 }
-//# sourceMappingURL=resourcePrisma.template.js.map

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

@@ -1,13 +1,6 @@
 /**
- * zudojs-cli — A resource's service and controller.
+ * zudojs-cli — A resource's service.
  */
 import type { ResourceNames } from "../resource.names.js";
 /** `services/<slug>.service.ts`: CRUD with NotFoundError for missing ids. */
 export declare function renderResourceService(n: ResourceNames): string;
-/**
- * `controllers/<slug>.controller.ts`: validates input with the DTO schemas
- * and maps service results to responses. Handlers are arrow properties so
- * they can be passed to the router unbound.
- */
-export declare function renderResourceController(n: ResourceNames, appSrcFromControllers: string): string;
-//# sourceMappingURL=resourceService.template.d.ts.map

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

@@ -1,11 +1,12 @@
 /**
- * zudojs-cli — A resource's service and controller.
+ * zudojs-cli — A resource's service.
  */
 /** `services/<slug>.service.ts`: CRUD with NotFoundError for missing ids. */
 export function renderResourceService(n) {
-    const types = `Create${n.entity}Input, ${n.entity}, Update${n.entity}Input`;
+    const types = `Create${n.entity}Input, ${n.entity}, ${n.entity}Page, List${n.pascal}Query, Update${n.entity}Input`;
     return `import { NotFoundError } from "@zudojs/errors";
 
+import { DEFAULT_PAGE_SIZE } from "../dtos/${n.slug}.dto.js";
 import type { ${types} } from "../dtos/${n.slug}.dto.js";
 import type { ${n.pascal}Repository } from "../repositories/${n.slug}.repository.js";
 
@@ -13,8 +14,12 @@ import type { ${n.pascal}Repository } from "../repositories/${n.slug}.repository
 export class ${n.pascal}Service {
   public constructor(private readonly repository: ${n.pascal}Repository) {}
 
-  public list(): Promise<readonly ${n.entity}[]> {
-    return this.repository.findAll();
+  /** One page of ${n.label} records (\`limit\` defaults to DEFAULT_PAGE_SIZE). */
+  public list(query: List${n.pascal}Query): Promise<${n.entity}Page> {
+    return this.repository.list({
+      limit: query.limit ?? DEFAULT_PAGE_SIZE,
+      ...(query.cursor === undefined ? {} : { cursor: query.cursor }),
+    });
   }
 
   public async get(id: string): Promise<${n.entity}> {
@@ -43,53 +48,3 @@ function notFound(id: string): NotFoundError {
 }
 `;
 }
-/**
- * `controllers/<slug>.controller.ts`: validates input with the DTO schemas
- * and maps service results to responses. Handlers are arrow properties so
- * they can be passed to the router unbound.
- */
-export function renderResourceController(n, appSrcFromControllers) {
-    const schemas = `Create${n.entity}Schema, ${n.entity}ParamsSchema, Update${n.entity}Schema`;
-    return `import type { HttpResponseContext, HttpRouterContext } from "@zudojs/http";
-
-import { ${schemas} } from "../dtos/${n.slug}.dto.js";
-import type { ${n.pascal}Service } from "../services/${n.slug}.service.js";
-import { empty, json, readJsonBody, validationFailed } from "${appSrcFromControllers}/utils/http.js";
-
-/** HTTP handlers for ${n.routePath}. */
-export class ${n.pascal}Controller {
-  public constructor(private readonly service: ${n.pascal}Service) {}
-
-  public readonly list = async (): Promise<HttpResponseContext> =>
-    json(200, await this.service.list());
-
-  public readonly get = async (ctx: HttpRouterContext): Promise<HttpResponseContext> => {
-    const params = ${n.entity}ParamsSchema.safeParse(ctx.params);
-    if (!params.success) return validationFailed(params.issues);
-    return json(200, await this.service.get(params.data.id));
-  };
-
-  public readonly create = async (ctx: HttpRouterContext): Promise<HttpResponseContext> => {
-    const body = Create${n.entity}Schema.safeParse(readJsonBody(ctx));
-    if (!body.success) return validationFailed(body.issues);
-    return json(201, await this.service.create(body.data));
-  };
-
-  public readonly update = async (ctx: HttpRouterContext): Promise<HttpResponseContext> => {
-    const params = ${n.entity}ParamsSchema.safeParse(ctx.params);
-    if (!params.success) return validationFailed(params.issues);
-    const body = Update${n.entity}Schema.safeParse(readJsonBody(ctx));
-    if (!body.success) return validationFailed(body.issues);
-    return json(200, await this.service.update(params.data.id, body.data));
-  };
-
-  public readonly remove = async (ctx: HttpRouterContext): Promise<HttpResponseContext> => {
-    const params = ${n.entity}ParamsSchema.safeParse(ctx.params);
-    if (!params.success) return validationFailed(params.issues);
-    await this.service.remove(params.data.id);
-    return empty(204);
-  };
-}
-`;
-}
-//# sourceMappingURL=resourceService.template.js.map

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

@@ -30,4 +30,3 @@ export interface ResourceWiring {
 }
 /** Describes how a resource is registered (see {@link ResourceWiring}). */
 export declare function resourceWiring(n: ResourceNames, layout: ResourceLayout): ResourceWiring;
-//# sourceMappingURL=resource.files.d.ts.map

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

@@ -36,7 +36,11 @@ export function resourceLayerPaths(n, layout, layer) {
         case "routes":
             return [joinPath(layout.base, "routes", `${n.slug}.routes.ts`)];
         case "test":
-            return [joinPath(layout.appRoot, "tests", `${n.slug}.test.ts`)];
+            // A module resource's test sits under tests/modules/<module>/, so two
+            // modules can each have a resource of the same name.
+            return [
+                joinPath(layout.appRoot, "tests", posix.relative(layout.appSrc, layout.base), `${n.slug}.test.ts`),
+            ];
     }
 }
 /** Renders `layers` of a resource as `{ path: content }`. */
@@ -65,11 +69,9 @@ export function renderResourceLayers(n, layout, layers) {
             case "routes":
                 files[path] = renderResourceRoutes(n);
                 break;
-            case "test": {
-                const tests = joinPath(layout.appRoot, "tests");
-                files[path] = renderResourceTest(n, posix.relative(tests, layout.base));
+            case "test":
+                files[path] = renderResourceTest(n, posix.relative(posix.dirname(path), layout.base));
                 break;
-            }
         }
     }
     return files;
@@ -96,4 +98,3 @@ export function resourceWiring(n, layout) {
         containerKey: key,
     };
 }
-//# sourceMappingURL=resource.files.js.map

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

@@ -41,4 +41,3 @@ export declare function resourceNames(raw: string): ResourceNames;
  * 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

@@ -72,4 +72,3 @@ export function withArticle(noun, capitalize = false) {
     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/resource/resource.type.d.ts

@@ -16,4 +16,3 @@ export interface ResourceLayout {
 export declare function toAppSrc(layout: ResourceLayout, layerDir: string): string;
 /** Joins path segments, dropping empty ones. */
 export declare function joinPath(...parts: readonly string[]): string;
-//# sourceMappingURL=resource.type.d.ts.map

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

@@ -12,4 +12,3 @@ export function toAppSrc(layout, layerDir) {
 export function joinPath(...parts) {
     return posix.join(...parts.filter((part) => part.length > 0));
 }
-//# sourceMappingURL=resource.type.js.map

package/dist/src/templates/shared/appRuntime.template.d.ts

@@ -52,4 +52,3 @@ export declare function renderModuleFile(options: {
 }): string;
 /** Renders a service class using the real `createLogger` factory. */
 export declare function renderServiceFile(name: string): string;
-//# sourceMappingURL=appRuntime.template.d.ts.map

package/dist/src/templates/shared/appRuntime.template.js

@@ -54,7 +54,6 @@ ${options.modules.map((m) => `    new ${m.className}(),`).join("\n")}${options.m
         : `\n      metadata: { port: ${options.port} },`;
     return `import type { Server } from "node:http";
 
-import { resolveEnvironment } from "@zudojs/constants";
 import { createContainer } from "@zudojs/container";
 import type { Module } from "@zudojs/core";
 import { createEventBus } from "@zudojs/events";
@@ -79,6 +78,10 @@ export interface AppOptions {
  * modules share, and the options describing this application. Integrations
  * (\`src/integrations\`) are registered first so they start before, and stop
  * after, every other module.
+ *
+ * The runtime's container is the one modules see as
+ * \`context.application.container\`; server.ts registers the composition
+ * root (\`container.ts\`) in it under \`APP_DEPENDENCIES\`.
  */
 export function createApp(options: AppOptions): Runtime {
   const logger = createLogger({ name: ${literal(options.applicationName)} });
@@ -97,9 +100,8 @@ ${registration}
     {
       applicationName: ${literal(options.applicationName)},
       applicationVersion: "0.1.0",
-      // NODE_ENV is read the same way the framework reads it: \`prod\` and
-      // \`Production\` are production, an unknown value warns once.
-      environment: resolveEnvironment(),
+      // Resolved once by loadConfig (configs/index.ts) from NODE_ENV.
+      environment: options.config.nodeEnv,
       // Signals are handled explicitly in server.ts.
       handleSignals: false,${metadata}
     },
@@ -166,4 +168,3 @@ export class ${className} {
 }
 `;
 }
-//# sourceMappingURL=appRuntime.template.js.map

package/dist/src/templates/shared/capability.template.d.ts

@@ -31,4 +31,3 @@ export declare function resolveProjectCapabilities(options: ScaffoldOptions): re
  * `zudojs add` and `zudojs doctor` use.
  */
 export declare function capabilityPackages(capabilities: readonly string[]): readonly string[];
-//# sourceMappingURL=capability.template.d.ts.map

package/dist/src/templates/shared/capability.template.js

@@ -59,4 +59,3 @@ export function capabilityPackages(capabilities) {
     }
     return [...packages];
 }
-//# sourceMappingURL=capability.template.js.map

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

@@ -32,4 +32,3 @@ export declare function lockedInstallSteps(packageManager: string): DockerInstal
  * 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

@@ -86,4 +86,3 @@ export function workspaceMemberInstallSteps(packageManager) {
             };
     }
 }
-//# sourceMappingURL=dockerfile.install.js.map

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

@@ -35,4 +35,3 @@ export declare function renderWorkspaceAppDockerfile(options: {
     readonly port: number;
     readonly packageManager: string;
 }): string;
-//# sourceMappingURL=dockerfile.template.d.ts.map