zudojs-cli 2.0.0 → 2.1.0

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

@@ -3,44 +3,30 @@
  *
  * Template file generators for monolith architecture projects.
  *
- * Generated structure:
+ * Generated structure (see `templates/backendApp` for the wired source):
  * ```
  * project/
  * ├── src/
- * │   ├── index.ts      # exports only
- * │   ├── app.ts        # application assembly
- * │   ├── server.ts     # entry point
- * │   ├── configs/
- * │   ├── constants/
- * │   ├── controllers/
- * │   ├── databases/
- * │   ├── dtos/
- * │   ├── enums/
- * │   ├── errors/
- * │   ├── events/
- * │   ├── interfaces/
- * │   ├── jobs/
- * │   ├── loaders/
- * │   ├── loggers/
- * │   ├── middlewares/
- * │   ├── models/
- * │   ├── modules/
- * │   ├── repositories/
- * │   ├── routes/
- * │   ├── services/
- * │   ├── types/
- * │   ├── utils/
- * │   └── validators/
- * ├── tests/
+ * │   ├── index.ts        # exports only
+ * │   ├── app.ts          # runtime assembly (modules + integrations)
+ * │   ├── server.ts       # config → router → registerRoutes → HTTP
+ * │   ├── container.ts    # composition root
+ * │   ├── configs/        # typed configuration from the environment
+ * │   ├── controllers/  dtos/  repositories/  services/  routes/
+ * │   ├── integrations/   # lifecycle-managed clients (zudojs add)
+ * │   ├── modules/        # runtime modules
+ * │   └── utils/          # HTTP helpers
+ * ├── tests/examples.test.ts
  * ├── package.json
  * ├── tsconfig.json
  * └── README.md
  * ```
  */
 import { renderDatabaseEnv } from "../../adapters/databases/databaseAdapter.resolver.js";
-import { ZUDOJS_PACKAGES_VERSION } from "../../constants/index.js";
+import { zudojsDependencies } from "../../constants/index.js";
 import { normalizeName, toPascalCase } from "../../utils/utils.name.js";
-import { RUNTIME_APP_DEPENDENCIES, capabilityPackages, moduleSpec, renderAppFile, renderModuleFile, renderServerFile, renderServiceFile, renderPnpmWorkspaceFile, resolveProjectCapabilities, } from "../shared/index.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";
 export function generateMonolithFiles(options) {
     const name = options.projectName;
     const nameSlug = name.replace(/[^a-z0-9-]+/gi, "-").toLowerCase();
@@ -49,25 +35,15 @@ export function generateMonolithFiles(options) {
     const capabilities = resolveProjectCapabilities(options);
     const deps = [
         ...RUNTIME_APP_DEPENDENCIES,
-        "@zudojs/config",
-        "@zudojs/errors",
+        ...APP_SOURCE_DEPENDENCIES,
         "@zudojs/types",
         "@zudojs/validation",
-        "@zudojs/schema",
-        "@zudojs/http",
         ...capabilityPackages(capabilities),
     ];
     if (options.enableCQRS) {
         deps.push("@zudojs/events");
     }
-    const devDeps = {
-        tsx: "^4.7.0",
-        typescript: "^5.7.0",
-        "@types/node": "^24.0.0",
-        vitest: "^3.0.0",
-    };
     const files = {};
-    // Root files
     files["package.json"] =
         JSON.stringify({
             name: nameSlug,
@@ -88,38 +64,16 @@ export function generateMonolithFiles(options) {
                 test: "vitest run",
                 lint: "tsc --noEmit",
             },
-            dependencies: Object.fromEntries([...new Set(deps)].map((d) => [d, ZUDOJS_PACKAGES_VERSION])),
-            devDependencies: devDeps,
+            dependencies: zudojsDependencies(deps),
+            devDependencies: {
+                ...backendDevDependencies(),
+                ...zudojsDependencies(APP_TEST_DEPENDENCIES),
+            },
         }, null, 2) + "\n";
-    // tsconfig
-    files["tsconfig.json"] = `{
-  "compilerOptions": {
-    "target": "ES2024",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "lib": ["ES2024"],
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}
-`;
+    files["tsconfig.json"] = backendTsconfig();
     if (options.packageManager === "pnpm") {
         files["pnpm-workspace.yaml"] = renderPnpmWorkspaceFile();
     }
-    // Environment
-    files[".env.example"] = `NODE_ENV=development
-PORT=3000
-
-${renderDatabaseEnv(options.database, nameSlug)}
-JWT_SECRET=change-this-in-production
-`;
     files[".gitignore"] = `node_modules/
 dist/
 .env
@@ -133,56 +87,53 @@ A Zudojs framework application.
 ## Getting Started
 
 \`\`\`bash
-${options.packageManager === "npm" ? "npm run dev" : options.packageManager === "yarn" ? "yarn dev" : options.packageManager === "bun" ? "bun run dev" : "pnpm run dev"}
+cp .env.example .env
+${runCommand(options.packageManager, "dev")}
+\`\`\`
+
+The server answers \`GET /health\` and the example resource at
+\`/api/v1/examples\`${options.enableOpenAPI ? "; the OpenAPI document is at `/openapi.json` and the docs page at `/docs`" : ""}.
+
+## Generate and add
+
+\`\`\`bash
+npx zudojs generate resource users   # DTO, repository, service, controller, routes, test — registered
+npx zudojs add redis                 # also: database, websockets, email, docker, queue, ...
 \`\`\`
 
 ## Structure
 
 \`\`\`
 src/
-├── server.ts        # Entry point
-├── app.ts           # Application assembly
-├── configs/         # Configuration
-├── constants/       # Shared constants
-├── controllers/     # HTTP controllers
-├── databases/       # Database connections
-├── dtos/            # Data transfer objects
-├── enums/           # Enumerations
-├── errors/          # Error types
-├── events/          # Domain events
-├── interfaces/      # Shared interfaces
-├── jobs/            # Background jobs
-├── loaders/         # Module loaders
-├── loggers/         # Logger configuration
-├── middlewares/     # HTTP middleware
-├── models/          # Data models
+├── server.ts        # Entry point: config, router, HTTP server
+├── app.ts           # Runtime assembly (modules + integrations)
+├── container.ts     # Composition root
+├── configs/         # Typed configuration (.env)
+├── controllers/     # HTTP handlers
+├── dtos/            # @zudojs/schema request/response schemas
+├── integrations/    # Redis, database, WebSockets, email (zudojs add)
 ├── modules/         # Runtime modules
-├── repositories/    # Data repositories
-├── routes/          # HTTP routes
-├── services/        # Application services
-├── types/           # Shared types
-├── utils/           # Utilities
-└── validators/      # Input validators
+├── repositories/    # Data access
+├── routes/          # registerRoutes and per-resource routes
+├── services/        # Use cases
+└── utils/           # HTTP helpers
 \`\`\`
 
 ## License
 
 MIT
 `;
-    // src/ entry points
-    files["src/index.ts"] = `export { createApp } from "./app.js";
-`;
-    files["src/server.ts"] = renderServerFile("./app.js", {
-        healthControllerImport: "./controllers/index.js",
-    });
     // Normalized: the name becomes a file path segment and a class name.
     const moduleName = normalizeName(options.services[0] ?? "app") || "app";
     const serviceClassName = `${toPascalCase(moduleName)}Service`;
     const appModule = moduleSpec(moduleName, "./modules/index.js");
-    files["src/app.ts"] = renderAppFile({
+    Object.assign(files, emptyBarrels(), applyDatabaseSetting(renderBackendAppSource({
         applicationName: nameSlug,
+        title: name,
+        defaultPort: 3000,
+        openapi: options.enableOpenAPI === true,
         modules: [appModule],
-    });
+    }), renderDatabaseEnv(options.database, nameSlug)));
     files[`src/modules/${moduleName}.module.ts`] = renderModuleFile({
         module: appModule,
         service: {
@@ -192,57 +143,9 @@ MIT
     });
     files["src/modules/index.ts"] =
         `export { ${appModule.className} } from "./${moduleName}.module.js";\n`;
-    // Shared directories with empty index.ts
-    const sharedDirs = [
-        "configs",
-        "constants",
-        "controllers",
-        "databases",
-        "dtos",
-        "enums",
-        "errors",
-        "events",
-        "interfaces",
-        "jobs",
-        "loaders",
-        "loggers",
-        "middlewares",
-        "models",
-        "repositories",
-        "routes",
-        "types",
-        "utils",
-        "validators",
-    ];
-    for (const dir of sharedDirs) {
-        files[`src/${dir}/index.ts`] = "";
-    }
-    // Services
     files[`src/services/${moduleName}.service.ts`] = renderServiceFile(moduleName);
     files["src/services/index.ts"] =
         `export { ${serviceClassName} } from "./${moduleName}.service.js";\n`;
-    // Controllers
-    files["src/controllers/health.controller.ts"] =
-        `export class HealthController {
-  check() {
-    return { status: "ok", timestamp: new Date().toISOString() };
-  }
-}
-`;
-    files["src/controllers/index.ts"] =
-        `export { HealthController } from "./health.controller.js";
-`;
-    // Tests. The file name must match vitest's default `include`
-    // (`**/*.{test,spec}.?(c|m)[jt]s?(x)`); `tests/index.ts` did not, so the
-    // generated `test` script exited 1 with "No test files found".
-    files["tests/app.test.ts"] = `import { describe, it, expect } from "vitest";
-
-describe("Application", () => {
-  it("should be configured correctly", () => {
-    expect(true).toBe(true);
-  });
-});
-`;
     return files;
 }
 //# sourceMappingURL=monolith.template.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * zudojs-cli — Resource templates: the DTO → repository → service →
+ * controller → routes chain, its test, and how it is registered.
+ */
+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

@@ -0,0 +1,9 @@
+/**
+ * zudojs-cli — Resource templates: the DTO → repository → service →
+ * controller → routes chain, its test, and how it is registered.
+ */
+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

@@ -0,0 +1,9 @@
+/**
+ * zudojs-cli — Resource layer templates: DTO, repositories, service,
+ * controller, routes and test.
+ */
+export * from "./resourceData.template.js";
+export * from "./resourcePrisma.template.js";
+export * from "./resourceService.template.js";
+export * from "./resourceRoutes.template.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * zudojs-cli — Resource layer templates: DTO, repositories, service,
+ * controller, routes and test.
+ */
+export * from "./resourceData.template.js";
+export * from "./resourcePrisma.template.js";
+export * from "./resourceService.template.js";
+export * from "./resourceRoutes.template.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * zudojs-cli — A resource's DTO schemas and in-memory repository.
+ */
+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

@@ -0,0 +1,108 @@
+/**
+ * zudojs-cli — A resource's DTO schemas and in-memory repository.
+ */
+/** `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. */
+export const ${n.entity}Schema = schema.object({
+  id: schema.string().uuid(),
+  name: schema.string(),
+  createdAt: schema.string(),
+  updatedAt: schema.string(),
+});
+
+/** Body of \`POST ${n.routePath}\`. Unknown fields are dropped. */
+export const Create${n.entity}Schema = schema.object({
+  name: schema.string().min(1).max(200),
+});
+
+/** Body of \`PATCH ${n.routePath}/:id\`. Every field is optional. */
+export const Update${n.entity}Schema = schema.object({
+  name: schema.string().min(1).max(200).optional(),
+});
+
+/** Path parameters of the \`${n.routePath}/:id\` routes. */
+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";
+
+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 {
+  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>;
+}
+
+/** 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);
+  }
+}
+`;
+}
+//# sourceMappingURL=resourceData.template.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * zudojs-cli — A resource's Prisma-backed repository and model.
+ *
+ * Generated only in an app that has Prisma (`zudojs add database`). The
+ * repository reads the client from `src/integrations/database.ts`, which
+ * the runtime connects on start.
+ */
+import type { ResourceNames } from "../resource.names.js";
+/** `repositories/<slug>.prisma.repository.ts`. */
+export declare function renderPrismaRepository(n: ResourceNames, appSrcFromRepositories: string): string;
+/** The Prisma model block appended to prisma/schema.prisma. */
+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

@@ -0,0 +1,89 @@
+/**
+ * zudojs-cli — A resource's Prisma-backed repository and model.
+ *
+ * Generated only in an app that has Prisma (`zudojs add database`). The
+ * repository reads the client from `src/integrations/database.ts`, which
+ * the runtime connects on start.
+ */
+/** `repositories/<slug>.prisma.repository.ts`. */
+export function renderPrismaRepository(n, appSrcFromRepositories) {
+    const types = `Create${n.entity}Input, ${n.entity}, 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";
+import type { ${n.pascal}Repository } from "./${n.slug}.repository.js";
+
+interface ${n.entity}Row {
+  readonly id: string;
+  readonly name: string;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+}
+
+function to${n.entity}(row: ${n.entity}Row): ${n.entity} {
+  return {
+    id: row.id,
+    name: row.name,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  };
+}
+
+/** 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}[]> {
+    const rows = await ${delegate}.findMany({
+      orderBy: { createdAt: "asc" },
+      take: LIST_LIMIT,
+    });
+    return rows.map(to${n.entity});
+  }
+
+  public async findById(id: string): Promise<${n.entity} | undefined> {
+    const row = await ${delegate}.findUnique({ where: { id } });
+    return row === null ? undefined : to${n.entity}(row);
+  }
+
+  public async create(input: Create${n.entity}Input): Promise<${n.entity}> {
+    return to${n.entity}(await ${delegate}.create({ data: { name: input.name } }));
+  }
+
+  public async update(
+    id: string,
+    input: Update${n.entity}Input,
+  ): Promise<${n.entity} | undefined> {
+    const result = await ${delegate}.updateMany({
+      where: { id },
+      data: input.name === undefined ? {} : { name: input.name },
+    });
+    return result.count === 0 ? undefined : this.findById(id);
+  }
+
+  public async delete(id: string): Promise<boolean> {
+    const result = await ${delegate}.deleteMany({ where: { id } });
+    return result.count > 0;
+  }
+}
+`;
+}
+/** The Prisma model block appended to prisma/schema.prisma. */
+export function renderPrismaModel(n) {
+    return `
+model ${n.entity} {
+  id        String   @id @default(uuid())
+  name      String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("${n.slug.replace(/-/g, "_")}")
+}
+`;
+}
+/** Whether `schema` already declares a model named `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/resourceRoutes.template.d.ts

@@ -0,0 +1,13 @@
+/**
+ * zudojs-cli — A resource's CRUD routes (with OpenAPI metadata) and test.
+ */
+import type { ResourceNames } from "../resource.names.js";
+/** `routes/<slug>.routes.ts`: `register<Pascal>Routes(router, controller)`. */
+export declare function renderResourceRoutes(n: ResourceNames): string;
+/**
+ * `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 declare function renderResourceTest(n: ResourceNames, baseFromTests: string): string;
+//# sourceMappingURL=resourceRoutes.template.d.ts.map