zudojs-cli 2.0.0 → 2.1.0

package/dist/src/resolvers/dependency/dependencyVersions.constant.js

@@ -1,40 +1,109 @@
 /**
- * Default version ranges for frontend dependencies the adapters request
- * without a version.
+ * Version ranges for every third-party package a generated project depends
+ * on: the ranges adapters request without a version, the framework
+ * toolchains the built-in fallback templates write, and the backend
+ * templates' dev tooling.
  *
  * Unpinned requirements used to be written as `"latest"`, so the same
- * scaffold produced a different dependency set every day. Every name a
- * built-in adapter requests unpinned has a caret range here (checked by
+ * scaffold produced a different dependency set every day, and the fallback
+ * templates carried their own literals that went stale independently (Vite
+ * 6, Next 15, Nuxt 3, Angular 19 and TypeScript 5 long after newer majors
+ * shipped). Every range now lives here. Every name a built-in adapter
+ * requests unpinned must have an entry (checked by
  * `tests/cli.round10.*.test.ts`). Ranges were taken from the npm registry on
- * 2026-09-19.
+ * 2026-09-23; pre-releases (for example Prisma 8 RCs or `@nuxt/devtools`
+ * betas tagged `latest`) are never used.
  */
-export const DEFAULT_DEPENDENCY_VERSIONS = new Map([
-    ["@angular-builders/jest", "^22.0.1"],
-    ["@angular/common", "^22.1.7"],
-    ["@angular/core", "^22.1.7"],
-    ["@ngrx/store", "^22.0.1"],
-    ["@testing-library/jest-dom", "^7.0.1"],
-    ["@testing-library/react", "^16.3.3"],
-    ["@testing-library/react-native", "^14.0.1"],
-    ["@testing-library/svelte", "^5.4.2"],
-    ["@testing-library/user-event", "^14.6.7"],
-    ["@vue/test-utils", "^2.5.1"],
-    ["eslint", "^10.11.0"],
-    ["eslint-plugin-react-hooks", "^7.1.1"],
-    ["eslint-plugin-react-refresh", "^0.5.7"],
-    ["eslint-plugin-svelte", "^3.23.0"],
-    ["eslint-plugin-vue", "^10.11.0"],
-    ["jest", "^30.5.2"],
-    ["jsdom", "^30.1.0"],
-    ["pinia", "^4.0.3"],
-    ["prettier", "^3.9.8"],
-    ["prettier-plugin-svelte", "^4.1.1"],
-    ["react", "^19.3.0"],
-    ["react-dom", "^19.3.0"],
-    ["svelte", "^5.57.1"],
-    ["typescript-eslint", "^8.70.0"],
-    ["vitest", "^5.0.1"],
-    ["vue", "^3.5.43"],
-    ["zustand", "^5.0.15"],
-]);
+export const DEPENDENCY_VERSION_RANGES = Object.freeze({
+    "@angular/build": "^22.1.8",
+    "@angular/cli": "^22.1.8",
+    "@angular/common": "^22.1.7",
+    "@angular/compiler": "^22.1.7",
+    "@angular/compiler-cli": "^22.1.7",
+    "@angular/core": "^22.1.7",
+    "@angular/forms": "^22.1.7",
+    "@angular/platform-browser": "^22.1.7",
+    "@angular/router": "^22.1.7",
+    "@astrojs/check": "^0.9.10",
+    "@ngrx/store": "^22.0.1",
+    "@prisma/adapter-pg": "^7.10.0",
+    "@prisma/client": "^7.10.0",
+    "@sveltejs/adapter-auto": "^7.0.1",
+    "@sveltejs/kit": "^2.70.3",
+    "@sveltejs/vite-plugin-svelte": "^7.3.1",
+    "@testing-library/dom": "^10.4.2",
+    "@testing-library/jest-dom": "^7.0.1",
+    "@testing-library/react": "^16.3.3",
+    "@testing-library/react-native": "^14.0.1",
+    "@testing-library/svelte": "^5.4.2",
+    "@testing-library/user-event": "^14.6.7",
+    "@tsconfig/svelte": "^5.0.8",
+    "@types/node": "^26.6.2",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@types/ws": "^8.18.1",
+    "@vitejs/plugin-react": "^6.1.1",
+    "@vitejs/plugin-vue": "^6.0.9",
+    "@vue/test-utils": "^2.5.1",
+    "@vue/tsconfig": "^0.9.1",
+    astro: "^7.3.4",
+    eslint: "^10.11.0",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.7",
+    "eslint-plugin-svelte": "^3.23.0",
+    "eslint-plugin-vue": "^10.11.0",
+    jest: "^30.5.2",
+    jsdom: "^30.1.1",
+    next: "^16.3.6",
+    nodemailer: "^10.0.10",
+    nuxt: "^4.5.2",
+    pinia: "^4.0.3",
+    prettier: "^3.9.9",
+    // Prisma 7 stable. npm's `latest` tag points at an 8.0 release
+    // candidate; a caret range never selects a pre-release.
+    prisma: "^7.10.0",
+    "prettier-plugin-svelte": "^4.1.1",
+    react: "^19.3.0",
+    "react-dom": "^19.3.0",
+    redis: "^6.2.1",
+    rxjs: "~7.8.2",
+    svelte: "^5.57.1",
+    "svelte-check": "^4.7.6",
+    tslib: "^2.8.1",
+    tsx: "^4.23.15",
+    "typescript-eslint": "^8.70.1",
+    vite: "^8.3.0",
+    vitest: "^5.0.1",
+    vue: "^3.5.43",
+    "vue-router": "^5.3.1",
+    "vue-tsc": "^3.3.11",
+    ws: "^8.21.3",
+    zustand: "^5.0.15",
+});
+/**
+ * TypeScript ranges, split by where the compiler runs.
+ *
+ * Backend templates only run `tsc` and `tsx`, so they get TypeScript 7.
+ * Frontend toolchains call the TypeScript 6 JavaScript API and declare it
+ * as a peer: `@angular/compiler-cli` and `@angular/build` need
+ * `>=6.0 <6.1`, `typescript-eslint` needs `<6.1.0`, and `@sveltejs/kit`,
+ * `svelte-check` and `@astrojs/check` need `^5 || ^6`. The frontend range is
+ * therefore a tilde range on 6.0 — do not raise it to 7 until those peer
+ * ranges admit it.
+ */
+export const TYPESCRIPT_VERSION_RANGES = Object.freeze({
+    backend: "^7.0.2",
+    frontend: "~6.0.3",
+});
+/**
+ * Vitest range for Angular projects. `@angular/build:unit-test` declares
+ * `vitest` `^4.0.8` as a peer, so Angular cannot take the Vitest 5 range the
+ * other frameworks use.
+ */
+export const ANGULAR_VITEST_VERSION_RANGE = "^4.1.11";
+/**
+ * Default ranges the dependency resolver applies to requirements that carry
+ * no version of their own.
+ */
+export const DEFAULT_DEPENDENCY_VERSIONS = new Map(Object.entries(DEPENDENCY_VERSION_RANGES));
 //# sourceMappingURL=dependencyVersions.constant.js.map

package/dist/src/resolvers/dependency/index.d.ts

@@ -4,5 +4,5 @@
  * @module resolvers/dependency
  */
 export { DependencyResolver, type DependencyResolutionResult, type ResolvedDependency, type DependencyConflict, } from "./dependencyResolver.core.js";
-export { DEFAULT_DEPENDENCY_VERSIONS } from "./dependencyVersions.constant.js";
+export { ANGULAR_VITEST_VERSION_RANGE, DEFAULT_DEPENDENCY_VERSIONS, DEPENDENCY_VERSION_RANGES, TYPESCRIPT_VERSION_RANGES, } from "./dependencyVersions.constant.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/resolvers/dependency/index.js

@@ -4,5 +4,5 @@
  * @module resolvers/dependency
  */
 export { DependencyResolver, } from "./dependencyResolver.core.js";
-export { DEFAULT_DEPENDENCY_VERSIONS } from "./dependencyVersions.constant.js";
+export { ANGULAR_VITEST_VERSION_RANGE, DEFAULT_DEPENDENCY_VERSIONS, DEPENDENCY_VERSION_RANGES, TYPESCRIPT_VERSION_RANGES, } from "./dependencyVersions.constant.js";
 //# sourceMappingURL=index.js.map

package/dist/src/resolvers/project.resolver.d.ts

@@ -1,3 +1,16 @@
+/** Options for {@link findProjectRoot}. */
+export interface FindProjectRootOptions {
+    /**
+     * Resolve an app inside a workspace to the workspace itself. Every
+     * microservice app and a fullstack `apps/api` carries a `zudojs` block in
+     * its own package.json, so the plain walk stops there and reports the app
+     * as a stand-alone monolith with no manifest. With this set, an ancestor
+     * holding `.zudojs/manifest.json` (or a legacy `zudojs.config.*`) wins.
+     * `add`, `doctor` and `info` describe the whole project and use it;
+     * `generate` and `build` keep working on the app they were run in.
+     */
+    readonly workspace?: boolean;
+}
 /**
  * Walks upward from `startDir` to the nearest directory that really is a
  * Zudojs project — one `resolveProjectLayout` recognizes: a
@@ -9,6 +22,6 @@
  * directory with no Zudojs project anywhere, `zudojs build` climbed to an
  * unrelated ancestor `package.json` and ran its `scripts.build`.
  */
-export declare function findProjectRoot(startDir?: string): string | null;
+export declare function findProjectRoot(startDir?: string, options?: FindProjectRootOptions): string | null;
 export declare function resolveProjectPath(cwd: string, name: string): string;
 //# sourceMappingURL=project.resolver.d.ts.map

package/dist/src/resolvers/project.resolver.js

@@ -1,5 +1,10 @@
+import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { resolveProjectLayout } from "./layout/projectLayout.core.js";
+/** Whether `dir` holds the project's own record rather than an app's block. */
+function holdsProjectRecord(dir) {
+    return ["zudojs.config.ts", "zudojs.config.js", join(".zudojs", "manifest.json")].some((name) => existsSync(join(dir, name)));
+}
 /**
  * Walks upward from `startDir` to the nearest directory that really is a
  * Zudojs project — one `resolveProjectLayout` recognizes: a
@@ -11,15 +16,18 @@ import { resolveProjectLayout } from "./layout/projectLayout.core.js";
  * directory with no Zudojs project anywhere, `zudojs build` climbed to an
  * unrelated ancestor `package.json` and ran its `scripts.build`.
  */
-export function findProjectRoot(startDir = process.cwd()) {
+export function findProjectRoot(startDir = process.cwd(), options = {}) {
     let dir = startDir;
+    let nearest = null;
     while (true) {
         if (resolveProjectLayout(dir) !== null) {
-            return dir;
+            if (options.workspace !== true || holdsProjectRecord(dir))
+                return dir;
+            nearest ??= dir;
         }
         const parent = dirname(dir);
         if (parent === dir) {
-            return null;
+            return nearest;
         }
         dir = parent;
     }

package/dist/src/scaffolders/scaffolder.helper.js

@@ -3,6 +3,8 @@
  *
  * Utilities for invoking official framework scaffolders.
  */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { execCommand } from "../utils/utils.exec.js";
 import { writeFileTree } from "../utils/utils.fileSystem.js";
 /**
@@ -35,12 +37,21 @@ export async function scaffoldWithFallback(options) {
             env: { ...process.env, CI: "1" },
             timeout: SCAFFOLD_TIMEOUT_MS,
         });
-        return true;
     }
     catch (error) {
         console.warn(`Warning: official scaffolder "${options.command} ${options.args.join(" ")}" ${describeFailure(error)}. Using built-in fallback template.`);
         await writeFileTree(options.targetPath, options.fallbackFiles);
         return false;
     }
+    // Some scaffolders exit 0 without writing anything: `create-vite` prints
+    // "Operation cancelled" when the directory is not empty. Treat a missing
+    // package.json as a failure whenever the fallback would have written one.
+    if (options.fallbackFiles["package.json"] !== undefined &&
+        !existsSync(join(options.targetPath, "package.json"))) {
+        console.warn(`Warning: official scaffolder "${options.command} ${options.args.join(" ")}" exited without creating package.json. Using built-in fallback template.`);
+        await writeFileTree(options.targetPath, options.fallbackFiles);
+        return false;
+    }
+    return true;
 }
 //# sourceMappingURL=scaffolder.helper.js.map

package/dist/src/templates/backendApp/backendApp.core.d.ts

@@ -0,0 +1,45 @@
+/**
+ * zudojs-cli — The source tree of one backend app.
+ *
+ * Monolith, modular monolith and every microservice app (gateway and
+ * services) share this layout, so `generate` and `add` work the same way
+ * in all of them:
+ *
+ * ```
+ * src/app.ts                 runtime assembly (modules + integrations)
+ * src/server.ts              config → router → registerRoutes → HTTP server
+ * src/container.ts           composition root (controllers, services, repositories)
+ * src/configs/index.ts       typed configuration from the environment
+ * src/routes/index.ts        registerRoutes(router, deps)
+ * src/routes/health.routes.ts
+ * src/integrations/          lifecycle-managed clients (zudojs add)
+ * src/utils/http.ts          response and body helpers, security headers
+ * src/{dtos,repositories,services,controllers,routes}/examples.*  example resource
+ * tests/examples.test.ts     HTTP test through createHttpTestClient
+ * ```
+ */
+import { type RuntimeModuleSpec } from "../shared/index.js";
+/** Options for {@link renderBackendAppSource}. */
+export interface BackendAppOptions {
+    /** Runtime and logger name. */
+    readonly applicationName: string;
+    /** OpenAPI document title. */
+    readonly title: string;
+    readonly defaultPort: number;
+    /** Mount /openapi.json and /docs. */
+    readonly openapi: boolean;
+    /** Runtime modules registered in app.ts. */
+    readonly modules: readonly RuntimeModuleSpec[];
+    /** Modules whose `routes/index.ts` is generated and registered. */
+    readonly routedModules?: readonly string[];
+    /** Port recorded as runtime metadata (microservice apps). */
+    readonly port?: number;
+}
+/** The example resource every new app ships with. */
+export declare const EXAMPLE_RESOURCE = "examples";
+/**
+ * Renders the app's files, keyed by path relative to the app root. The
+ * caller adds package.json, tsconfig.json and the empty folder barrels.
+ */
+export declare function renderBackendAppSource(options: BackendAppOptions): Record<string, string>;
+//# sourceMappingURL=backendApp.core.d.ts.map

package/dist/src/templates/backendApp/backendApp.core.js

@@ -0,0 +1,66 @@
+/**
+ * zudojs-cli — The source tree of one backend app.
+ *
+ * Monolith, modular monolith and every microservice app (gateway and
+ * services) share this layout, so `generate` and `add` work the same way
+ * in all of them:
+ *
+ * ```
+ * src/app.ts                 runtime assembly (modules + integrations)
+ * src/server.ts              config → router → registerRoutes → HTTP server
+ * src/container.ts           composition root (controllers, services, repositories)
+ * src/configs/index.ts       typed configuration from the environment
+ * src/routes/index.ts        registerRoutes(router, deps)
+ * src/routes/health.routes.ts
+ * src/integrations/          lifecycle-managed clients (zudojs add)
+ * src/utils/http.ts          response and body helpers, security headers
+ * src/{dtos,repositories,services,controllers,routes}/examples.*  example resource
+ * tests/examples.test.ts     HTTP test through createHttpTestClient
+ * ```
+ */
+import { renderAppFile, renderServerFile, } from "../shared/index.js";
+import { renderResourceLayers, resourceNames, resourceWiring, RESOURCE_LAYERS, } from "../resource/index.js";
+import { baseEnvVariables, renderConfigFile, renderContainer, renderEnvVariables, renderHealthRoutes, renderHttpUtils, renderIntegrationContract, renderIntegrationsIndex, renderModuleRoutesIndex, renderRoutesIndex, } from "./parts/index.js";
+import { moduleRoutesWiring } from "./backendApp.modules.js";
+/** The example resource every new app ships with. */
+export const EXAMPLE_RESOURCE = "examples";
+/**
+ * Renders the app's files, keyed by path relative to the app root. The
+ * caller adds package.json, tsconfig.json and the empty folder barrels.
+ */
+export function renderBackendAppSource(options) {
+    const names = resourceNames(EXAMPLE_RESOURCE);
+    const layout = { base: "src", appSrc: "src", appRoot: "", prisma: false };
+    const example = resourceWiring(names, layout);
+    const modules = (options.routedModules ?? []).map(moduleRoutesWiring);
+    const files = {
+        "src/index.ts": `export { createApp } from "./app.js";\n`,
+        "src/app.ts": renderAppFile({
+            applicationName: options.applicationName,
+            modules: options.modules,
+            ...(options.port === undefined ? {} : { port: options.port }),
+        }),
+        "src/server.ts": renderServerFile({ title: options.title, openapi: options.openapi }),
+        "src/configs/index.ts": renderConfigFile({ defaultPort: options.defaultPort, sections: [] }),
+        "src/container.ts": renderContainer({
+            imports: example.containerImports,
+            entries: [example.containerEntry],
+        }),
+        "src/routes/index.ts": renderRoutesIndex({
+            imports: [example.routeImport, ...modules.map((m) => m.importLine)],
+            entries: [example.routeEntry, ...modules.map((m) => m.entryLine)],
+        }),
+        "src/routes/health.routes.ts": renderHealthRoutes(),
+        "src/integrations/index.ts": renderIntegrationsIndex({ imports: [], entries: [] }),
+        "src/integrations/integration.ts": renderIntegrationContract(),
+        "src/utils/http.ts": renderHttpUtils(),
+        "src/utils/index.ts": `export * from "./http.js";\n`,
+        ".env.example": `${renderEnvVariables(baseEnvVariables(options.defaultPort))}\n`,
+        ...renderResourceLayers(names, layout, RESOURCE_LAYERS),
+    };
+    for (const module of modules) {
+        files[module.indexPath] = renderModuleRoutesIndex(module.functionName, "../../../container.js");
+    }
+    return files;
+}
+//# sourceMappingURL=backendApp.core.js.map

package/dist/src/templates/backendApp/backendApp.modules.d.ts

@@ -0,0 +1,26 @@
+/**
+ * zudojs-cli — How a module's routes are registered with its app.
+ *
+ * A module `billing` owns `src/modules/billing/routes/index.ts`, which
+ * exports `registerBillingModuleRoutes(router, deps)`. The app's
+ * `src/routes/index.ts` imports and calls it between its markers.
+ *
+ * The `Module` infix keeps it apart from a resource's
+ * `registerBillingRoutes`: both used to be imported into the same
+ * `src/routes/index.ts` after `generate module billing` and
+ * `generate route billing`, and the app failed on the duplicate identifier.
+ */
+/** The registration of one module's routes. */
+export interface ModuleRoutesWiring {
+    readonly module: string;
+    readonly functionName: string;
+    /** The module's routes index, relative to the app root. */
+    readonly indexPath: string;
+    /** Import line for the app's src/routes/index.ts. */
+    readonly importLine: string;
+    /** Call for the app's src/routes/index.ts. */
+    readonly entryLine: string;
+}
+/** Describes the routes wiring of module `name`. */
+export declare function moduleRoutesWiring(name: string): ModuleRoutesWiring;
+//# sourceMappingURL=backendApp.modules.d.ts.map

package/dist/src/templates/backendApp/backendApp.modules.js

@@ -0,0 +1,25 @@
+/**
+ * zudojs-cli — How a module's routes are registered with its app.
+ *
+ * A module `billing` owns `src/modules/billing/routes/index.ts`, which
+ * exports `registerBillingModuleRoutes(router, deps)`. The app's
+ * `src/routes/index.ts` imports and calls it between its markers.
+ *
+ * The `Module` infix keeps it apart from a resource's
+ * `registerBillingRoutes`: both used to be imported into the same
+ * `src/routes/index.ts` after `generate module billing` and
+ * `generate route billing`, and the app failed on the duplicate identifier.
+ */
+import { toPascalCase } from "../../utils/utils.name.js";
+/** Describes the routes wiring of module `name`. */
+export function moduleRoutesWiring(name) {
+    const functionName = `register${toPascalCase(name)}ModuleRoutes`;
+    return {
+        module: name,
+        functionName,
+        indexPath: `src/modules/${name}/routes/index.ts`,
+        importLine: `import { ${functionName} } from "../modules/${name}/routes/index.js";`,
+        entryLine: `${functionName}(router, deps);`,
+    };
+}
+//# sourceMappingURL=backendApp.modules.js.map

package/dist/src/templates/backendApp/backendApp.project.d.ts

@@ -0,0 +1,26 @@
+/**
+ * zudojs-cli — Project files shared by every backend architecture:
+ * dependency lists, dev tooling, tsconfig, folder barrels and the database
+ * setting every app records.
+ */
+/** `@zudojs/*` packages the shared app source imports. */
+export declare const APP_SOURCE_DEPENDENCIES: readonly string[];
+/** `@zudojs/*` packages the generated tests import. */
+export declare const APP_TEST_DEPENDENCIES: readonly string[];
+/** Third-party dev tooling of a backend app. */
+export declare function backendDevDependencies(): Record<string, string>;
+/** tsconfig.json of a backend app (tests are compiled by Vitest, not tsc). */
+export declare function backendTsconfig(): string;
+/** `src/<folder>/index.ts` barrels for {@link APP_FOLDERS}. */
+export declare function emptyBarrels(): Record<string, string>;
+/** The config entry for the database URL. */
+export declare const DATABASE_CONFIG_SECTION = "database: Object.freeze({ url: text(config, \"database_url\", \"\") }),";
+/**
+ * Records the project's database URL: in `.env.example` (`envLines`, e.g.
+ * `DATABASE_URL=postgresql://localhost:5432/shop`) and as the `database`
+ * section of `src/configs/index.ts`.
+ */
+export declare function applyDatabaseSetting(files: Record<string, string>, envLines: string): Record<string, string>;
+/** `<pm> run <script>` for a package manager. */
+export declare function runCommand(packageManager: string, script: string): string;
+//# sourceMappingURL=backendApp.project.d.ts.map

package/dist/src/templates/backendApp/backendApp.project.js

@@ -0,0 +1,87 @@
+/**
+ * zudojs-cli — Project files shared by every backend architecture:
+ * dependency lists, dev tooling, tsconfig, folder barrels and the database
+ * setting every app records.
+ */
+import { DEPENDENCY_VERSION_RANGES, TYPESCRIPT_VERSION_RANGES, } from "../../resolvers/dependency/dependencyVersions.constant.js";
+import { MARKERS, insertBetweenMarkers } from "../../wiring/index.js";
+/** `@zudojs/*` packages the shared app source imports. */
+export const APP_SOURCE_DEPENDENCIES = [
+    "@zudojs/config",
+    "@zudojs/errors",
+    "@zudojs/http",
+    "@zudojs/schema",
+    "@zudojs/security",
+];
+/** `@zudojs/*` packages the generated tests import. */
+export const APP_TEST_DEPENDENCIES = ["@zudojs/testing"];
+/** Third-party dev tooling of a backend app. */
+export function backendDevDependencies() {
+    return {
+        tsx: DEPENDENCY_VERSION_RANGES.tsx,
+        typescript: TYPESCRIPT_VERSION_RANGES.backend,
+        "@types/node": DEPENDENCY_VERSION_RANGES["@types/node"],
+        vitest: DEPENDENCY_VERSION_RANGES.vitest,
+    };
+}
+/** tsconfig.json of a backend app (tests are compiled by Vitest, not tsc). */
+export function backendTsconfig() {
+    return `{
+  "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"]
+}
+`;
+}
+/** Folders every app has, each with an (initially empty) barrel. */
+const APP_FOLDERS = [
+    "constants", "controllers", "databases", "dtos", "enums", "errors", "events",
+    "interfaces", "jobs", "loaders", "loggers", "middlewares", "models",
+    "repositories", "services", "types", "validators",
+];
+/** `src/<folder>/index.ts` barrels for {@link APP_FOLDERS}. */
+export function emptyBarrels() {
+    return Object.fromEntries(APP_FOLDERS.map((dir) => [`src/${dir}/index.ts`, ""]));
+}
+/** The config entry for the database URL. */
+export const DATABASE_CONFIG_SECTION = `database: Object.freeze({ url: text(config, "database_url", "") }),`;
+/**
+ * Records the project's database URL: in `.env.example` (`envLines`, e.g.
+ * `DATABASE_URL=postgresql://localhost:5432/shop`) and as the `database`
+ * section of `src/configs/index.ts`.
+ */
+export function applyDatabaseSetting(files, envLines) {
+    const config = files["src/configs/index.ts"];
+    if (config !== undefined) {
+        files["src/configs/index.ts"] = insertBetweenMarkers(config, MARKERS.config, DATABASE_CONFIG_SECTION).source;
+    }
+    const env = files[".env.example"] ?? "";
+    files[".env.example"] = `${env}${envLines}\n`;
+    return files;
+}
+/** `<pm> run <script>` for a package manager. */
+export function runCommand(packageManager, script) {
+    switch (packageManager) {
+        case "npm":
+            return `npm run ${script}`;
+        case "yarn":
+            return `yarn ${script}`;
+        case "bun":
+            return `bun run ${script}`;
+        default:
+            return `pnpm run ${script}`;
+    }
+}
+//# sourceMappingURL=backendApp.project.js.map

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

@@ -0,0 +1,8 @@
+/**
+ * zudojs-cli — Backend app source tree shared by every architecture.
+ */
+export * from "./backendApp.core.js";
+export * from "./backendApp.modules.js";
+export * from "./backendApp.project.js";
+export * from "./parts/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * zudojs-cli — Backend app source tree shared by every architecture.
+ */
+export * from "./backendApp.core.js";
+export * from "./backendApp.modules.js";
+export * from "./backendApp.project.js";
+export * from "./parts/index.js";
+//# sourceMappingURL=index.js.map

package/dist/src/templates/backendApp/parts/config.template.d.ts

@@ -0,0 +1,28 @@
+/**
+ * zudojs-cli — Generated `src/configs/index.ts` and `.env.example`.
+ *
+ * Configuration is read from the environment through @zudojs/config and
+ * returned as one frozen, typed object. `zudojs add <feature>` inserts that
+ * feature's section between the `config` markers and its variables into
+ * `.env.example`, so the two stay in sync.
+ */
+/** One environment variable documented in `.env.example`. */
+export interface EnvVariable {
+    readonly name: string;
+    readonly value: string;
+    readonly comment?: string;
+}
+/** Variables every generated app reads. */
+export declare function baseEnvVariables(port: number): readonly EnvVariable[];
+/** Renders `.env.example` lines for `variables`. */
+export declare function renderEnvVariables(variables: readonly EnvVariable[]): string;
+/**
+ * Renders `src/configs/index.ts`. `sections` are single-line object entries
+ * (for example `redis: Object.freeze({ url: text(config, "redis_url", "...") }),`)
+ * placed between the config markers.
+ */
+export declare function renderConfigFile(options: {
+    readonly defaultPort: number;
+    readonly sections: readonly string[];
+}): string;
+//# sourceMappingURL=config.template.d.ts.map