zudojs-cli 2.0.1 → 2.1.1

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

@@ -0,0 +1,128 @@
+/**
+ * zudojs-cli — A resource's CRUD routes (with OpenAPI metadata) and test.
+ */
+/** `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`;
+    return `import type { HttpRouter } from "@zudojs/http";
+import { schema } from "@zudojs/schema";
+
+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,
+      responses: { "200": { description: "Every ${n.label}", schema: schema.array(${n.entity}Schema) } },
+    },
+  });
+
+  router.get(\`\${BASE_PATH}/:id\`, controller.get, {
+    openapi: {
+      summary: "Get a ${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 a ${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 a ${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 a ${n.label}",
+      tags: TAGS,
+      params: ${n.entity}ParamsSchema,
+      responses: { "204": { description: "Deleted" }, "400": invalid, "404": missing },
+    },
+  });
+}
+`;
+}
+/**
+ * `tests/<slug>.test.ts`: drives the routes over real HTTP with
+ * `createHttpTestClient`, backed by the in-memory repository.
+ * `baseFromTests` is the import prefix from the tests folder to the layers.
+ */
+export function renderResourceTest(n, baseFromTests) {
+    const b = baseFromTests;
+    return `import { afterAll, describe, 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 { 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 a ${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.get("${n.routePath}").expect(200);
+    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("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);
+  });
+});
+`;
+}
+//# sourceMappingURL=resourceRoutes.template.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * zudojs-cli — A resource's service and controller.
+ */
+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

@@ -0,0 +1,95 @@
+/**
+ * zudojs-cli — A resource's service and controller.
+ */
+/** `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`;
+    return `import { NotFoundError } from "@zudojs/errors";
+
+import type { ${types} } from "../dtos/${n.slug}.dto.js";
+import type { ${n.pascal}Repository } from "../repositories/${n.slug}.repository.js";
+
+/** ${n.entity} use cases. Throws NotFoundError (404) for an unknown id. */
+export class ${n.pascal}Service {
+  public constructor(private readonly repository: ${n.pascal}Repository) {}
+
+  public list(): Promise<readonly ${n.entity}[]> {
+    return this.repository.findAll();
+  }
+
+  public async get(id: string): Promise<${n.entity}> {
+    const record = await this.repository.findById(id);
+    if (record === undefined) throw notFound(id);
+    return record;
+  }
+
+  public create(input: Create${n.entity}Input): Promise<${n.entity}> {
+    return this.repository.create(input);
+  }
+
+  public async update(id: string, input: Update${n.entity}Input): Promise<${n.entity}> {
+    const record = await this.repository.update(id, input);
+    if (record === undefined) throw notFound(id);
+    return record;
+  }
+
+  public async remove(id: string): Promise<void> {
+    if (!(await this.repository.delete(id))) throw notFound(id);
+  }
+}
+
+function notFound(id: string): NotFoundError {
+  return new NotFoundError(\`${n.entity} "\${id}" was not found.\`);
+}
+`;
+}
+/**
+ * `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

@@ -0,0 +1,33 @@
+/**
+ * zudojs-cli — The files and registrations of one resource.
+ *
+ * Shared by `zudojs create` (the example resource every new app ships
+ * with) and `zudojs generate resource|route|controller|repository|dto`, so
+ * a generated resource and the scaffolded one are identical.
+ */
+import type { ResourceNames } from "./resource.names.js";
+import { type ResourceLayout } from "./resource.type.js";
+/** A resource layer; each is one file (the repository may add a second). */
+export type ResourceLayer = "dto" | "repository" | "service" | "controller" | "routes" | "test";
+/** Layers in dependency order: each needs the ones before it. */
+export declare const RESOURCE_LAYERS: readonly ResourceLayer[];
+/** Path of each layer's file(s), relative to the project root. */
+export declare function resourceLayerPaths(n: ResourceNames, layout: ResourceLayout, layer: ResourceLayer): readonly string[];
+/** Renders `layers` of a resource as `{ path: content }`. */
+export declare function renderResourceLayers(n: ResourceNames, layout: ResourceLayout, layers: readonly ResourceLayer[]): Record<string, string>;
+/** The lines that register a resource in routes and the container. */
+export interface ResourceWiring {
+    /** routes/index.ts next to the resource's routes file. */
+    readonly routesIndex: string;
+    readonly routeImport: string;
+    readonly routeEntry: string;
+    /** The app's src/container.ts. */
+    readonly container: string;
+    readonly containerImports: readonly string[];
+    readonly containerEntry: string;
+    /** The key the controller is stored under in the container. */
+    readonly containerKey: string;
+}
+/** 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

@@ -0,0 +1,99 @@
+/**
+ * zudojs-cli — The files and registrations of one resource.
+ *
+ * Shared by `zudojs create` (the example resource every new app ships
+ * with) and `zudojs generate resource|route|controller|repository|dto`, so
+ * a generated resource and the scaffolded one are identical.
+ */
+import { posix } from "node:path";
+import { renderPrismaRepository, renderResourceController, renderResourceDto, renderResourceRepository, renderResourceRoutes, renderResourceService, renderResourceTest, } from "./layers/index.js";
+import { joinPath, toAppSrc } from "./resource.type.js";
+/** Layers in dependency order: each needs the ones before it. */
+export const RESOURCE_LAYERS = [
+    "dto",
+    "repository",
+    "service",
+    "controller",
+    "routes",
+    "test",
+];
+/** Path of each layer's file(s), relative to the project root. */
+export function resourceLayerPaths(n, layout, layer) {
+    switch (layer) {
+        case "dto":
+            return [joinPath(layout.base, "dtos", `${n.slug}.dto.ts`)];
+        case "repository":
+            return [
+                joinPath(layout.base, "repositories", `${n.slug}.repository.ts`),
+                ...(layout.prisma
+                    ? [joinPath(layout.base, "repositories", `${n.slug}.prisma.repository.ts`)]
+                    : []),
+            ];
+        case "service":
+            return [joinPath(layout.base, "services", `${n.slug}.service.ts`)];
+        case "controller":
+            return [joinPath(layout.base, "controllers", `${n.slug}.controller.ts`)];
+        case "routes":
+            return [joinPath(layout.base, "routes", `${n.slug}.routes.ts`)];
+        case "test":
+            return [joinPath(layout.appRoot, "tests", `${n.slug}.test.ts`)];
+    }
+}
+/** Renders `layers` of a resource as `{ path: content }`. */
+export function renderResourceLayers(n, layout, layers) {
+    const files = {};
+    for (const layer of layers) {
+        const [path, second] = resourceLayerPaths(n, layout, layer);
+        if (path === undefined)
+            continue;
+        switch (layer) {
+            case "dto":
+                files[path] = renderResourceDto(n);
+                break;
+            case "repository":
+                files[path] = renderResourceRepository(n);
+                if (second !== undefined) {
+                    files[second] = renderPrismaRepository(n, toAppSrc(layout, "repositories"));
+                }
+                break;
+            case "service":
+                files[path] = renderResourceService(n);
+                break;
+            case "controller":
+                files[path] = renderResourceController(n, toAppSrc(layout, "controllers"));
+                break;
+            case "routes":
+                files[path] = renderResourceRoutes(n);
+                break;
+            case "test": {
+                const tests = joinPath(layout.appRoot, "tests");
+                files[path] = renderResourceTest(n, posix.relative(tests, layout.base));
+                break;
+            }
+        }
+    }
+    return files;
+}
+/** Describes how a resource is registered (see {@link ResourceWiring}). */
+export function resourceWiring(n, layout) {
+    const fromSrc = posix.relative(layout.appSrc, layout.base);
+    const prefix = fromSrc === "" ? "." : `./${fromSrc}`;
+    const repository = layout.prisma
+        ? { name: `Prisma${n.pascal}Repository`, file: `${n.slug}.prisma.repository.js` }
+        : { name: `InMemory${n.pascal}Repository`, file: `${n.slug}.repository.js` };
+    const key = `${n.camel}Controller`;
+    return {
+        routesIndex: joinPath(layout.base, "routes", "index.ts"),
+        routeImport: `import { register${n.pascal}Routes } from "./${n.slug}.routes.js";`,
+        routeEntry: `register${n.pascal}Routes(router, deps.${key});`,
+        container: joinPath(layout.appSrc, "container.ts"),
+        containerImports: [
+            `import { ${n.pascal}Controller } from "${prefix}/controllers/${n.slug}.controller.js";`,
+            `import { ${repository.name} } from "${prefix}/repositories/${repository.file}";`,
+            `import { ${n.pascal}Service } from "${prefix}/services/${n.slug}.service.js";`,
+        ],
+        containerEntry: `${key}: new ${n.pascal}Controller(new ${n.pascal}Service(new ${repository.name}())),`,
+        containerKey: key,
+    };
+}
+//# sourceMappingURL=resource.files.js.map

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

@@ -0,0 +1,38 @@
+/**
+ * zudojs-cli — Names derived from a resource name.
+ *
+ * `users` gives the file slug `users`, the classes `UsersController`,
+ * `UsersService` and `UsersRepository`, the record type `User`, the Prisma
+ * model `User` (delegate `user`, table `users`) and the path
+ * `/api/v1/users`.
+ */
+/** Every identifier and path a resource's files use. */
+export interface ResourceNames {
+    /** kebab-case slug: file names, table name, OpenAPI tag. */
+    readonly slug: string;
+    /** PascalCase of the name as given: class prefix (`UsersService`). */
+    readonly pascal: string;
+    /** camelCase of the name as given: container key prefix. */
+    readonly camel: string;
+    /** PascalCase singular: record type and schema prefix (`User`). */
+    readonly entity: string;
+    /** camelCase singular: Prisma delegate (`prisma.user`). */
+    readonly entityCamel: string;
+    /** Human label for messages and summaries (`user`). */
+    readonly label: string;
+    /** Collection path (`/api/v1/users`). */
+    readonly routePath: string;
+}
+/** Naive English singular, enough for resource names (`users` → `user`). */
+export declare function singularize(slug: string): string;
+/**
+ * Derives {@link ResourceNames} from a raw name.
+ *
+ * A name containing a path separator or `..` is refused outright rather
+ * than normalized: `generate resource ../../x` used to be accepted and
+ * silently became `x`, which hides a typo or an attack in a script.
+ *
+ * @throws {CLIValidationError} For unusable or reserved names.
+ */
+export declare function resourceNames(raw: string): ResourceNames;
+//# sourceMappingURL=resource.names.d.ts.map

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

@@ -0,0 +1,60 @@
+/**
+ * zudojs-cli — Names derived from a resource name.
+ *
+ * `users` gives the file slug `users`, the classes `UsersController`,
+ * `UsersService` and `UsersRepository`, the record type `User`, the Prisma
+ * model `User` (delegate `user`, table `users`) and the path
+ * `/api/v1/users`.
+ */
+import { CLIValidationError } from "../../errors/index.js";
+import { assertGeneratableName, toCamelCase, toPascalCase, } from "../../utils/utils.name.js";
+/**
+ * Names that would shadow a global the generated files rely on (a `Record`
+ * entity type hides TypeScript's `Record<K, V>`, `Promise` breaks every
+ * async signature).
+ */
+const RESERVED_ENTITY_NAMES = new Set([
+    "Array", "Boolean", "Date", "Error", "Function", "Headers", "Map", "Number",
+    "Object", "Promise", "Record", "Request", "Response", "Set", "String",
+    "Symbol", "URL",
+]);
+/** Naive English singular, enough for resource names (`users` → `user`). */
+export function singularize(slug) {
+    if (/ies$/.test(slug) && slug.length > 4)
+        return `${slug.slice(0, -3)}y`;
+    if (/(ses|xes|zes|ches|shes)$/.test(slug))
+        return slug.slice(0, -2);
+    if (/[^s]s$/.test(slug))
+        return slug.slice(0, -1);
+    return slug;
+}
+/**
+ * Derives {@link ResourceNames} from a raw name.
+ *
+ * A name containing a path separator or `..` is refused outright rather
+ * than normalized: `generate resource ../../x` used to be accepted and
+ * silently became `x`, which hides a typo or an attack in a script.
+ *
+ * @throws {CLIValidationError} For unusable or reserved names.
+ */
+export function resourceNames(raw) {
+    if (/[\\/]|\.\./.test(raw)) {
+        throw new CLIValidationError(`Invalid resource name: "${raw}". Use a plain name such as "users"; paths are not allowed.`);
+    }
+    const slug = assertGeneratableName(raw, "resource name");
+    const singular = singularize(slug);
+    const entity = toPascalCase(singular);
+    if (RESERVED_ENTITY_NAMES.has(entity)) {
+        throw new CLIValidationError(`Invalid resource name: "${raw}". "${entity}" would shadow a JavaScript global; choose another name (for example "${slug}-items").`);
+    }
+    return {
+        slug,
+        pascal: toPascalCase(slug),
+        camel: toCamelCase(slug),
+        entity,
+        entityCamel: toCamelCase(singular),
+        label: singular.replace(/-/g, " "),
+        routePath: `/api/v1/${slug}`,
+    };
+}
+//# sourceMappingURL=resource.names.js.map

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

@@ -0,0 +1,19 @@
+/**
+ * zudojs-cli — Where a resource's files go.
+ */
+/** Placement of a resource inside a generated project (POSIX, relative). */
+export interface ResourceLayout {
+    /** Directory the layer folders live in: `src`, `src/modules/billing`. */
+    readonly base: string;
+    /** The app's source root: `src`, `apps/gateway/src`. */
+    readonly appSrc: string;
+    /** The app's root (holds package.json): `""`, `apps/gateway`. */
+    readonly appRoot: string;
+    /** Whether the app has Prisma set up (prisma/schema.prisma exists). */
+    readonly prisma: boolean;
+}
+/** Import prefix from a layer folder of `layout` to the app's src root. */
+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

@@ -0,0 +1,15 @@
+/**
+ * zudojs-cli — Where a resource's files go.
+ */
+import { posix } from "node:path";
+/** Import prefix from a layer folder of `layout` to the app's src root. */
+export function toAppSrc(layout, layerDir) {
+    const from = posix.join(layout.base, layerDir);
+    const rel = posix.relative(from, layout.appSrc);
+    return rel === "" ? "." : rel;
+}
+/** Joins path segments, dropping empty ones. */
+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.js

@@ -41,39 +41,56 @@ export function renderAppFile(options) {
     const imports = [...options.modules]
         .map((m) => `import { ${m.className} } from ${literal(m.importPath)};`)
         .join("\n");
-    // An empty array literal would make the loop variable `never`, so the
-    // registration loop is only emitted when there is at least one module.
-    const registration = options.modules.length > 0
-        ? `  for (const module of [
-${options.modules.map((m) => `    new ${m.className}(),`).join("\n")}
-  ]) {
+    // The list always exists, even when empty, so `zudojs generate module`
+    // can register into it; the cast keeps an empty literal from being
+    // typed `never[]`.
+    const registration = `  for (const module of [
+${options.modules.map((m) => `    new ${m.className}(),`).join("\n")}${options.modules.length > 0 ? "\n" : ""}  ] as Module[]) {
     modules.set(module.id, module);
   }
-`
-        : "";
+`;
     const metadata = options.port === undefined
         ? ""
         : `\n      metadata: { port: ${options.port} },`;
-    return `import { resolveEnvironment } from "@zudojs/constants";
+    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";
 import { createLogger } from "@zudojs/logger";
 import { createRuntime, type Runtime } from "@zudojs/runtime";
+
+import type { AppConfig } from "./configs/index.js";
+import { IntegrationsModule, integrations } from "./integrations/index.js";
 ${imports}
 
+/** What {@link createApp} needs. */
+export interface AppOptions {
+  readonly config: AppConfig;
+  /** The Node HTTP server, for integrations that attach to it. */
+  readonly httpServer?: Server;
+}
+
 /**
  * Assembles the application runtime.
  *
  * \`createRuntime\` takes two arguments: the dependencies the runtime and its
- * modules share, and the options describing this application.
+ * modules share, and the options describing this application. Integrations
+ * (\`src/integrations\`) are registered first so they start before, and stop
+ * after, every other module.
  */
-export function createApp(): Runtime {
+export function createApp(options: AppOptions): Runtime {
   const logger = createLogger({ name: ${literal(options.applicationName)} });
   const container = createContainer();
   const eventBus = createEventBus();
 
   const modules = new Map<string, Module>();
+  const integrationsModule = new IntegrationsModule(integrations, {
+    config: options.config,
+    ...(options.httpServer === undefined ? {} : { httpServer: options.httpServer }),
+  });
+  modules.set(integrationsModule.id, integrationsModule);
 ${registration}
   const runtime = createRuntime(
     { modules, logger, container, eventBus },

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

@@ -8,13 +8,22 @@
  * every project the CLI created, and `zudojs add` was the only thing that
  * could ever put a value there.
  *
- * The list produced here is the same one `zudojs create` records as
- * `capabilities` in `.zudojs/manifest.json`, and {@link capabilityPackages}
- * gives the packages that back it, so a declared feature is always installed.
+ * {@link resolveProjectCapabilities} is the single source of truth for what
+ * a new project was created with: `zudojs create` records exactly this list
+ * as `capabilities` in `.zudojs/manifest.json` and as `zudojs.features` in
+ * every backend app's package.json, and {@link capabilityPackages} gives the
+ * packages that back it, so a declared feature is always installed.
  */
 import type { ScaffoldOptions } from "../../types/index.js";
 /**
- * The capability ids a scaffolded project was created with.
+ * The capability ids a scaffolded project was created with: the `enable*`
+ * flags in manifest order, then the selected capabilities that have no flag
+ * (`events`, `security`) in the order they were chosen.
+ *
+ * Those two used to reach the manifest but not package.json, so
+ * `--capabilities events,cqrs` recorded `["cqrs","events"]` in one and
+ * `["cqrs"]` in the other. A frontend-only project has no backend app to
+ * carry a capability and records none.
  */
 export declare function resolveProjectCapabilities(options: ScaffoldOptions): readonly string[];
 /**

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

@@ -8,9 +8,11 @@
  * every project the CLI created, and `zudojs add` was the only thing that
  * could ever put a value there.
  *
- * The list produced here is the same one `zudojs create` records as
- * `capabilities` in `.zudojs/manifest.json`, and {@link capabilityPackages}
- * gives the packages that back it, so a declared feature is always installed.
+ * {@link resolveProjectCapabilities} is the single source of truth for what
+ * a new project was created with: `zudojs create` records exactly this list
+ * as `capabilities` in `.zudojs/manifest.json` and as `zudojs.features` in
+ * every backend app's package.json, and {@link capabilityPackages} gives the
+ * packages that back it, so a declared feature is always installed.
  */
 import { FEATURE_PACKAGES } from "../../constants/index.js";
 /** Capability flags, in the order the manifest records them. */
@@ -23,10 +25,24 @@ const CAPABILITY_FLAGS = [
     ["queue", "enableQueue"],
 ];
 /**
- * The capability ids a scaffolded project was created with.
+ * The capability ids a scaffolded project was created with: the `enable*`
+ * flags in manifest order, then the selected capabilities that have no flag
+ * (`events`, `security`) in the order they were chosen.
+ *
+ * Those two used to reach the manifest but not package.json, so
+ * `--capabilities events,cqrs` recorded `["cqrs","events"]` in one and
+ * `["cqrs"]` in the other. A frontend-only project has no backend app to
+ * carry a capability and records none.
  */
 export function resolveProjectCapabilities(options) {
-    return CAPABILITY_FLAGS.filter(([, flag]) => options[flag] === true).map(([capability]) => capability);
+    if (options.projectType === "frontend")
+        return [];
+    const capabilities = CAPABILITY_FLAGS.filter(([, flag]) => options[flag] === true).map(([capability]) => capability);
+    for (const capability of options.capabilities ?? []) {
+        if (!capabilities.includes(capability))
+            capabilities.push(capability);
+    }
+    return capabilities;
 }
 /**
  * The `@zudojs/*` packages that back `capabilities`, using the same mapping