zudojs-cli 2.1.3 → 2.2.0

package/dist/src/templates/microservice/microservice.template.js

@@ -26,7 +26,7 @@ import { zudojsDependencies } from "../../constants/index.js";
 import { normalizeName } from "../../utils/utils.name.js";
 import { RUNTIME_APP_DEPENDENCIES, capabilityPackages, moduleSpec, renderAppPackageDockerfile, renderModuleFile, renderPnpmWorkspaceFile, resolveProjectCapabilities, } from "../shared/index.js";
 import { DEPENDENCY_VERSION_RANGES, TYPESCRIPT_VERSION_RANGES, } from "../../resolvers/dependency/dependencyVersions.constant.js";
-import { APP_SOURCE_DEPENDENCIES, APP_TEST_DEPENDENCIES, applyDatabaseSetting, backendDevDependencies, emptyBarrels, renderBackendAppSource, } from "../backendApp/index.js";
+import { APP_SOURCE_DEPENDENCIES, APP_TEST_DEPENDENCIES, applyDatabaseSetting, backendAppScripts, backendDevDependencies, backendTsconfigFiles, emptyBarrels, renderBackendAppSource, } from "../backendApp/index.js";
 /**
  * The gateway app is always generated at `apps/gateway`, so "gateway" is a
  * reserved name: a service called `gateway` would produce a second, competing
@@ -205,33 +205,13 @@ MIT
     // app there, so nothing would compile a file placed in it. Every app owns
     // its own `src/types/`, and code genuinely shared between apps belongs in a
     // workspace package the author creates deliberately.
-    const appTsconfig = `{
-  "compilerOptions": {
-    "target": "ES2024",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "lib": ["ES2024"],
-    "types": ["node"]
-  },
-  "include": ["src/**/*"]
-}
-`;
+    /** tsconfig.json and tsconfig.test.json of one app, under `appDir`. */
+    const appTsconfigs = (appDir) => Object.fromEntries(Object.entries(backendTsconfigFiles()).map(([name, content]) => [`${appDir}/${name}`, content]));
     const appDevDeps = {
         ...backendDevDependencies(),
         ...zudojsDependencies(APP_TEST_DEPENDENCIES),
     };
-    const appScripts = {
-        dev: "tsx watch src/server.ts",
-        start: "node dist/server.js",
-        build: "tsc",
-        typecheck: "tsc --noEmit",
-        test: "vitest run",
-    };
+    const appScripts = backendAppScripts();
     /** The wired source tree of one app, plus its folder barrels. */
     const appSource = (appName, port) => {
         const spec = moduleSpec(appName, "./modules/index.js");
@@ -273,7 +253,7 @@ MIT
             dependencies: zudojsDependencies(gatewayDeps),
             devDependencies: appDevDeps,
         }, null, 2) + "\n";
-    files["apps/gateway/tsconfig.json"] = appTsconfig;
+    Object.assign(files, appTsconfigs("apps/gateway"));
     files["apps/gateway/Dockerfile"] = renderAppPackageDockerfile({
         appPath: "apps/gateway",
         port: 3000,
@@ -301,7 +281,7 @@ MIT
                 dependencies: zudojsDependencies(serviceDeps),
                 devDependencies: appDevDeps,
             }, null, 2) + "\n";
-        files[`apps/services/${svcName}/tsconfig.json`] = appTsconfig;
+        Object.assign(files, appTsconfigs(`apps/services/${svcName}`));
         files[`apps/services/${svcName}/Dockerfile`] = renderAppPackageDockerfile({
             appPath: `apps/services/${svcName}`,
             port,
@@ -313,4 +293,3 @@ MIT
     }
     return files;
 }
-//# sourceMappingURL=microservice.template.js.map

package/dist/src/templates/modular-monolith/index.d.ts

@@ -2,4 +2,3 @@
  * zudojs-cli — Modular Monolith Template Index
  */
 export { generateModularMonolithFiles } from "./modularMonolith.template.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/templates/modular-monolith/index.js

@@ -2,4 +2,3 @@
  * zudojs-cli — Modular Monolith Template Index
  */
 export { generateModularMonolithFiles } from "./modularMonolith.template.js";
-//# sourceMappingURL=index.js.map

package/dist/src/templates/modular-monolith/modularMonolith.template.d.ts

@@ -33,4 +33,3 @@
  */
 import type { ScaffoldOptions } from "../../types/index.js";
 export declare function generateModularMonolithFiles(options: ScaffoldOptions): Record<string, string>;
-//# sourceMappingURL=modularMonolith.template.d.ts.map

package/dist/src/templates/modular-monolith/modularMonolith.template.js

@@ -35,7 +35,7 @@ import { renderDatabaseEnv } from "../../adapters/databases/databaseAdapter.reso
 import { zudojsDependencies } from "../../constants/index.js";
 import { normalizeName } from "../../utils/utils.name.js";
 import { RUNTIME_APP_DEPENDENCIES, capabilityPackages, moduleSpec, renderModuleFile, renderPnpmWorkspaceFile, resolveProjectCapabilities, } from "../shared/index.js";
-import { APP_SOURCE_DEPENDENCIES, APP_TEST_DEPENDENCIES, applyDatabaseSetting, backendDevDependencies, backendTsconfig, emptyBarrels, renderBackendAppSource, runCommand, } from "../backendApp/index.js";
+import { APP_SOURCE_DEPENDENCIES, APP_TEST_DEPENDENCIES, applyDatabaseSetting, backendAppScripts, backendDevDependencies, backendTsconfigFiles, emptyBarrels, renderBackendAppSource, runCommand, } from "../backendApp/index.js";
 export function generateModularMonolithFiles(options) {
     const nameSlug = options.projectName
         .replace(/[^a-z0-9-]+/gi, "-")
@@ -77,20 +77,14 @@ export function generateModularMonolithFiles(options) {
                 architecture: "modular-monolith",
                 features: capabilities,
             },
-            scripts: {
-                dev: "tsx watch src/server.ts",
-                start: "node dist/server.js",
-                build: "tsc",
-                typecheck: "tsc --noEmit",
-                test: "vitest run",
-            },
+            scripts: backendAppScripts(),
             dependencies: zudojsDependencies(deps),
             devDependencies: {
                 ...backendDevDependencies(),
                 ...zudojsDependencies(APP_TEST_DEPENDENCIES),
             },
         }, null, 2) + "\n";
-    files["tsconfig.json"] = backendTsconfig();
+    Object.assign(files, backendTsconfigFiles());
     if (options.packageManager === "pnpm") {
         files["pnpm-workspace.yaml"] = renderPnpmWorkspaceFile();
     }
@@ -159,4 +153,3 @@ MIT
     }
     return files;
 }
-//# sourceMappingURL=modularMonolith.template.js.map

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

@@ -2,4 +2,3 @@
  * zudojs-cli — Monolith Template Index
  */
 export { generateMonolithFiles } from "./monolith.template.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -2,4 +2,3 @@
  * zudojs-cli — Monolith Template Index
  */
 export { generateMonolithFiles } from "./monolith.template.js";
-//# sourceMappingURL=index.js.map

package/dist/src/templates/monolith/monolith.template.d.ts

@@ -24,4 +24,3 @@
  */
 import type { ScaffoldOptions } from "../../types/index.js";
 export declare function generateMonolithFiles(options: ScaffoldOptions): Record<string, string>;
-//# sourceMappingURL=monolith.template.d.ts.map

package/dist/src/templates/monolith/monolith.template.js

@@ -26,7 +26,7 @@ import { renderDatabaseEnv } from "../../adapters/databases/databaseAdapter.reso
 import { zudojsDependencies } from "../../constants/index.js";
 import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
 import { RUNTIME_APP_DEPENDENCIES, capabilityPackages, moduleSpec, renderModuleFile, renderServiceFile, renderPnpmWorkspaceFile, resolveProjectCapabilities, } from "../shared/index.js";
-import { APP_SOURCE_DEPENDENCIES, APP_TEST_DEPENDENCIES, applyDatabaseSetting, backendDevDependencies, backendTsconfig, emptyBarrels, runCommand, renderBackendAppSource, } from "../backendApp/index.js";
+import { APP_SOURCE_DEPENDENCIES, APP_TEST_DEPENDENCIES, applyDatabaseSetting, backendAppScripts, backendDevDependencies, backendTsconfigFiles, emptyBarrels, runCommand, renderBackendAppSource, } from "../backendApp/index.js";
 export function generateMonolithFiles(options) {
     const name = options.projectName;
     const nameSlug = name.replace(/[^a-z0-9-]+/gi, "-").toLowerCase();
@@ -56,21 +56,14 @@ export function generateMonolithFiles(options) {
                 architecture: "monolith",
                 features: capabilities,
             },
-            scripts: {
-                dev: "tsx watch src/server.ts",
-                start: "node dist/server.js",
-                build: "tsc",
-                typecheck: "tsc --noEmit",
-                test: "vitest run",
-                lint: "tsc --noEmit",
-            },
+            scripts: backendAppScripts(),
             dependencies: zudojsDependencies(deps),
             devDependencies: {
                 ...backendDevDependencies(),
                 ...zudojsDependencies(APP_TEST_DEPENDENCIES),
             },
         }, null, 2) + "\n";
-    files["tsconfig.json"] = backendTsconfig();
+    Object.assign(files, backendTsconfigFiles());
     if (options.packageManager === "pnpm") {
         files["pnpm-workspace.yaml"] = renderPnpmWorkspaceFile();
     }
@@ -148,4 +141,3 @@ MIT
         `export { ${serviceClassName} } from "./${moduleName}.service.js";\n`;
     return files;
 }
-//# sourceMappingURL=monolith.template.js.map

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

@@ -6,4 +6,3 @@ export * from "./resource.names.js";
 export * from "./resource.type.js";
 export * from "./resource.files.js";
 export * from "./layers/index.js";
-//# sourceMappingURL=index.d.ts.map

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

@@ -6,4 +6,3 @@ export * from "./resource.names.js";
 export * from "./resource.type.js";
 export * from "./resource.files.js";
 export * from "./layers/index.js";
-//# sourceMappingURL=index.js.map

package/dist/src/templates/resource/layers/index.d.ts

@@ -1,9 +1,9 @@
 /**
- * zudojs-cli — Resource layer templates: DTO, repositories, service,
- * controller, routes and test.
+ * zudojs-cli — Resource layer templates: DTO, repositories (in-memory and
+ * Prisma), service, and the HTTP layers (controller, routes, test).
  */
 export * from "./resourceData.template.js";
+export * from "./resourceMemory.template.js";
 export * from "./resourcePrisma.template.js";
 export * from "./resourceService.template.js";
-export * from "./resourceRoutes.template.js";
-//# sourceMappingURL=index.d.ts.map
+export * from "./resourceHttp/index.js";

package/dist/src/templates/resource/layers/index.js

@@ -1,9 +1,9 @@
 /**
- * zudojs-cli — Resource layer templates: DTO, repositories, service,
- * controller, routes and test.
+ * zudojs-cli — Resource layer templates: DTO, repositories (in-memory and
+ * Prisma), service, and the HTTP layers (controller, routes, test).
  */
 export * from "./resourceData.template.js";
+export * from "./resourceMemory.template.js";
 export * from "./resourcePrisma.template.js";
 export * from "./resourceService.template.js";
-export * from "./resourceRoutes.template.js";
-//# sourceMappingURL=index.js.map
+export * from "./resourceHttp/index.js";

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

@@ -1,9 +1,13 @@
 /**
- * zudojs-cli — A resource's DTO schemas and in-memory repository.
+ * zudojs-cli — A resource's DTO schemas: record, create/update bodies, path
+ * parameters, and the list query and page shape.
+ *
+ * List endpoints paginate with a cursor: `?limit=` (1–MAX_PAGE_SIZE,
+ * default DEFAULT_PAGE_SIZE) and `?cursor=<id of the last item seen>`. A
+ * page answers `{ items, nextCursor }`, `nextCursor` being `null` on the
+ * last page. They used to return every record at once — up to 10,000 from
+ * the in-memory store.
  */
 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. */
-export declare function renderResourceRepository(n: ResourceNames): string;
-//# sourceMappingURL=resourceData.template.d.ts.map

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

@@ -1,5 +1,12 @@
 /**
- * zudojs-cli — A resource's DTO schemas and in-memory repository.
+ * zudojs-cli — A resource's DTO schemas: record, create/update bodies, path
+ * parameters, and the list query and page shape.
+ *
+ * List endpoints paginate with a cursor: `?limit=` (1–MAX_PAGE_SIZE,
+ * default DEFAULT_PAGE_SIZE) and `?cursor=<id of the last item seen>`. A
+ * page answers `{ items, nextCursor }`, `nextCursor` being `null` on the
+ * last page. They used to return every record at once — up to 10,000 from
+ * the in-memory store.
  */
 import { withArticle } from "../resource.names.js";
 /** `dtos/<slug>.dto.ts`: @zudojs/schema schemas and their inferred types. */
@@ -29,81 +36,32 @@ export const ${n.entity}ParamsSchema = schema.object({
   id: schema.string().uuid(),
 });
 
-export type ${n.entity} = Infer<typeof ${n.entity}Schema>;
-export type Create${n.entity}Input = Infer<typeof Create${n.entity}Schema>;
-export type Update${n.entity}Input = Infer<typeof Update${n.entity}Schema>;
-`;
-}
-/** `repositories/<slug>.repository.ts`: the contract and a memory store. */
-export function renderResourceRepository(n) {
-    const types = `Create${n.entity}Input, ${n.entity}, Update${n.entity}Input`;
-    return `import { randomUUID } from "node:crypto";
+/** Page size when \`limit\` is not given, and the most a client may ask for. */
+export const DEFAULT_PAGE_SIZE = 50;
+export const MAX_PAGE_SIZE = 200;
 
-import { ConflictError } from "@zudojs/errors";
+/** Query of \`GET ${n.routePath}\`: page size and the id to continue after. */
+export const List${n.pascal}QuerySchema = schema.object({
+  limit: schema.coerce.number().int().min(1).max(MAX_PAGE_SIZE).optional(),
+  cursor: schema.string().uuid().optional(),
+});
 
-import type { ${types} } from "../dtos/${n.slug}.dto.js";
+/** One page of ${n.label} records; \`nextCursor\` is null on the last page. */
+export const ${n.entity}PageSchema = schema.object({
+  items: schema.array(${n.entity}Schema),
+  nextCursor: schema.nullable(schema.string().uuid()),
+});
 
-/** Storage contract for ${n.label} records; the service depends on this only. */
-export interface ${n.pascal}Repository {
-  findAll(): Promise<readonly ${n.entity}[]>;
-  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>;
+/** What a repository is asked for: a page size and where to continue. */
+export interface ${n.entity}PageRequest {
+  readonly limit: number;
+  readonly cursor?: string;
 }
 
-/** 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 findAll(): Promise<readonly ${n.entity}[]> {
-    return [...this.records.values()];
-  }
-
-  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);
-  }
-}
+export type ${n.entity} = Infer<typeof ${n.entity}Schema>;
+export type Create${n.entity}Input = Infer<typeof Create${n.entity}Schema>;
+export type Update${n.entity}Input = Infer<typeof Update${n.entity}Schema>;
+export type List${n.pascal}Query = Infer<typeof List${n.pascal}QuerySchema>;
+export type ${n.entity}Page = Infer<typeof ${n.entity}PageSchema>;
 `;
 }
-//# sourceMappingURL=resourceData.template.js.map

package/dist/src/templates/resource/layers/resourceHttp/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — HTTP layers of a resource: controller, routes and test.
+ */
+export * from "./resourceController.template.js";
+export * from "./resourceRoutes.template.js";
+export * from "./resourceTest.template.js";

package/dist/src/templates/resource/layers/resourceHttp/index.js

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — HTTP layers of a resource: controller, routes and test.
+ */
+export * from "./resourceController.template.js";
+export * from "./resourceRoutes.template.js";
+export * from "./resourceTest.template.js";

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

@@ -0,0 +1,10 @@
+/**
+ * zudojs-cli — A resource's controller.
+ */
+import type { ResourceNames } from "../../resource.names.js";
+/**
+ * `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;

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;