zudojs-cli 1.1.1 → 1.2.0

package/README.md

@@ -2,6 +2,12 @@
 
 Command-line interface for scaffolding, generating, and managing Zudojs framework projects.
 
+<!-- zudo-docs:start -->
+
+**Documentation:** [zudojs.oyinlola.site/docs/packages-cli](https://zudojs.oyinlola.site/docs/packages-cli) · **For AI agents:** [Markdown version](https://zudojs.oyinlola.site/docs/packages-cli.md), [llms.txt](https://zudojs.oyinlola.site/llms.txt)
+
+<!-- zudo-docs:end -->
+
 ## Installation
 
 ### First time
@@ -75,6 +81,27 @@ block of `package.json`. Every follow-up command reads those; no
 ranges, and projects created for pnpm carry a `pnpm-workspace.yaml` that
 allows esbuild's build script, which pnpm 10+ would otherwise refuse to run.
 
+- **A running server.** `src/server.ts` starts the runtime and serves HTTP
+  with `@zudojs/http` on `PORT` (default 3000; each microservice app on its
+  own port), answering `GET /health`. SIGINT/SIGTERM stop the HTTP server,
+  then the runtime.
+- **Databases:** `--database postgresql|mysql|sqlite` sets `DATABASE_URL` in
+  `.env.example` and the database container. `mongodb` is not supported.
+- **Language:** backend code is TypeScript. `--language javascript` is
+  rejected for `--type backend`; in a fullstack project it applies to the
+  frontend only.
+- **Fullstack + microservice:** the gateway and services are written at
+  `apps/gateway` and `apps/services/<name>`, next to `apps/web`, and are part
+  of the root workspace.
+
+### Generating code
+
+`zudojs generate module <name>` writes a runtime module (a `BaseModule`
+subclass), exports it from the modules barrel and registers it in `app.ts`.
+`zudojs generate` refuses to overwrite a file that already exists and would
+change, and lists those files; pass `--force` to overwrite them. Barrels are
+only appended to. `--dry-run` lists the files without writing anything.
+
 ## Commands
 
 | Command    | Description                                                              |

package/dist/src/adapters/databases/databaseAdapter.resolver.d.ts

@@ -0,0 +1,21 @@
+/**
+ * zudojs-cli — Database adapter lookup.
+ *
+ * `--database mysql|sqlite` used to be accepted and then ignored: every
+ * template hard-coded a PostgreSQL `DATABASE_URL`, and the MySQL/SQLite
+ * adapters were exported but never called. Templates and the
+ * InfrastructureGenerator resolve the adapter here instead. `mongodb` has
+ * no adapter, so it is rejected rather than silently turned into Postgres.
+ */
+import type { DatabaseAdapter } from "./postgres.adapter.js";
+/** Database engines the CLI can scaffold. */
+export declare const SUPPORTED_DATABASES: readonly ["postgresql", "mysql", "sqlite"];
+/**
+ * Returns the adapter for a database engine.
+ *
+ * @throws {CLIValidationError} For an engine with no adapter (e.g. `mongodb`).
+ */
+export declare function resolveDatabaseAdapter(database?: string): DatabaseAdapter;
+/** Renders the adapter's environment variables as `.env` lines. */
+export declare function renderDatabaseEnv(database: string | undefined, dbName: string): string;
+//# sourceMappingURL=databaseAdapter.resolver.d.ts.map

package/dist/src/adapters/databases/databaseAdapter.resolver.js

@@ -0,0 +1,40 @@
+/**
+ * zudojs-cli — Database adapter lookup.
+ *
+ * `--database mysql|sqlite` used to be accepted and then ignored: every
+ * template hard-coded a PostgreSQL `DATABASE_URL`, and the MySQL/SQLite
+ * adapters were exported but never called. Templates and the
+ * InfrastructureGenerator resolve the adapter here instead. `mongodb` has
+ * no adapter, so it is rejected rather than silently turned into Postgres.
+ */
+import { CLIValidationError } from "../../errors/index.js";
+import { MySqlAdapter } from "./mysql.adapter.js";
+import { PostgresAdapter } from "./postgres.adapter.js";
+import { SqliteAdapter } from "./sqlite.adapter.js";
+/** Database engines the CLI can scaffold. */
+export const SUPPORTED_DATABASES = ["postgresql", "mysql", "sqlite"];
+const FACTORIES = new Map([
+    ["postgresql", () => new PostgresAdapter()],
+    ["mysql", () => new MySqlAdapter()],
+    ["sqlite", () => new SqliteAdapter()],
+]);
+/**
+ * Returns the adapter for a database engine.
+ *
+ * @throws {CLIValidationError} For an engine with no adapter (e.g. `mongodb`).
+ */
+export function resolveDatabaseAdapter(database = "postgresql") {
+    const factory = FACTORIES.get(database);
+    if (!factory) {
+        throw new CLIValidationError(`Unsupported database "${database}". Supported: ${SUPPORTED_DATABASES.join(", ")}.`);
+    }
+    return factory();
+}
+/** Renders the adapter's environment variables as `.env` lines. */
+export function renderDatabaseEnv(database, dbName) {
+    const variables = resolveDatabaseAdapter(database).getEnvironmentVariables(dbName);
+    return Object.entries(variables)
+        .map(([key, value]) => `${key}=${value}`)
+        .join("\n");
+}
+//# sourceMappingURL=databaseAdapter.resolver.js.map

package/dist/src/adapters/databases/index.d.ts

@@ -1,4 +1,5 @@
 export { PostgresAdapter } from "./postgres.adapter.js";
 export { MySqlAdapter } from "./mysql.adapter.js";
 export { SqliteAdapter } from "./sqlite.adapter.js";
+export { SUPPORTED_DATABASES, renderDatabaseEnv, resolveDatabaseAdapter, } from "./databaseAdapter.resolver.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/databases/index.js

@@ -1,4 +1,5 @@
 export { PostgresAdapter } from "./postgres.adapter.js";
 export { MySqlAdapter } from "./mysql.adapter.js";
 export { SqliteAdapter } from "./sqlite.adapter.js";
+export { SUPPORTED_DATABASES, renderDatabaseEnv, resolveDatabaseAdapter, } from "./databaseAdapter.resolver.js";
 //# sourceMappingURL=index.js.map

package/dist/src/adapters/databases/mysql.adapter.d.ts

@@ -7,6 +7,6 @@ export declare class MySqlAdapter implements DatabaseAdapter {
     readonly driver = "mysql";
     getConnectionString(dbName: string): string;
     getDependencies(): readonly string[];
-    getEnvironmentVariables(): Record<string, string>;
+    getEnvironmentVariables(dbName?: string): Record<string, string>;
 }
 //# sourceMappingURL=mysql.adapter.d.ts.map

package/dist/src/adapters/databases/mysql.adapter.js

@@ -10,9 +10,9 @@ export class MySqlAdapter {
     getDependencies() {
         return ["@zudojs/database"];
     }
-    getEnvironmentVariables() {
+    getEnvironmentVariables(dbName = "mydb") {
         return {
-            DATABASE_URL: "mysql://localhost:3306/mydb",
+            DATABASE_URL: this.getConnectionString(dbName),
         };
     }
 }

package/dist/src/adapters/databases/postgres.adapter.d.ts

@@ -8,13 +8,14 @@ export interface DatabaseAdapter {
     readonly driver: string;
     getConnectionString(dbName: string): string;
     getDependencies(): readonly string[];
-    getEnvironmentVariables(): Record<string, string>;
+    /** Environment variables for a database named `dbName` (default "mydb"). */
+    getEnvironmentVariables(dbName?: string): Record<string, string>;
 }
 export declare class PostgresAdapter implements DatabaseAdapter {
     readonly name = "postgresql";
     readonly driver = "postgres";
     getConnectionString(dbName: string): string;
     getDependencies(): readonly string[];
-    getEnvironmentVariables(): Record<string, string>;
+    getEnvironmentVariables(dbName?: string): Record<string, string>;
 }
 //# sourceMappingURL=postgres.adapter.d.ts.map

package/dist/src/adapters/databases/postgres.adapter.js

@@ -12,9 +12,9 @@ export class PostgresAdapter {
     getDependencies() {
         return ["@zudojs/database"];
     }
-    getEnvironmentVariables() {
+    getEnvironmentVariables(dbName = "mydb") {
         return {
-            DATABASE_URL: "postgresql://localhost:5432/mydb",
+            DATABASE_URL: this.getConnectionString(dbName),
         };
     }
 }

package/dist/src/adapters/databases/sqlite.adapter.d.ts

@@ -7,6 +7,6 @@ export declare class SqliteAdapter implements DatabaseAdapter {
     readonly driver = "sqlite";
     getConnectionString(dbName: string): string;
     getDependencies(): readonly string[];
-    getEnvironmentVariables(): Record<string, string>;
+    getEnvironmentVariables(dbName?: string): Record<string, string>;
 }
 //# sourceMappingURL=sqlite.adapter.d.ts.map

package/dist/src/adapters/databases/sqlite.adapter.js

@@ -10,9 +10,9 @@ export class SqliteAdapter {
     getDependencies() {
         return ["@zudojs/database"];
     }
-    getEnvironmentVariables() {
+    getEnvironmentVariables(dbName = "mydb") {
         return {
-            DATABASE_URL: "sqlite:mydb.db",
+            DATABASE_URL: this.getConnectionString(dbName),
         };
     }
 }

package/dist/src/bin/zudojs.js

@@ -56,7 +56,7 @@ app.register(createCommand({
         {
             name: "database",
             short: "d",
-            description: "Database engine (postgresql, mysql, sqlite, mongodb)",
+            description: "Database engine (postgresql, mysql, sqlite)",
             type: "string",
             defaultValue: "postgresql",
         },
@@ -176,6 +176,12 @@ app.register(createCommand({
             type: "boolean",
             defaultValue: false,
         },
+        {
+            name: "force",
+            description: "Overwrite existing files the schematic would change",
+            type: "boolean",
+            defaultValue: false,
+        },
     ],
     execute: async (context) => {
         await runGenerateCommand(context);

package/dist/src/commands/add.command.js

@@ -64,7 +64,11 @@ export async function runAddCommand(context) {
     if (!feature) {
         throw new CLIValidationError(`Feature name is required. Available: ${available}`);
     }
-    const packages = FEATURE_PACKAGES[feature];
+    // Own keys only: `constructor` or `__proto__` resolved to Object.prototype
+    // members and crashed with "packages.join is not a function".
+    const packages = Object.hasOwn(FEATURE_PACKAGES, feature)
+        ? FEATURE_PACKAGES[feature]
+        : undefined;
     if (!packages) {
         throw new CLIValidationError(`Unknown feature: "${feature}". Available: ${available}`);
     }

package/dist/src/commands/create.command.js

@@ -12,6 +12,7 @@ import { FrontendGenerator } from "../generators/frontend/frontendGenerator.core
 import { FullstackComposer } from "../generators/fullstack/fullstackComposer.core.js";
 import { IntegrationGenerator } from "../generators/integration/integrationGenerator.core.js";
 import { InfrastructureGenerator } from "../generators/infrastructure/infrastructure.generator.js";
+import { layoutFullstackBackend } from "../generators/fullstack/fullstackBackend.layout.js";
 import { BackendGenerator } from "../generators/backend/backend.generator.js";
 import { RollbackManager } from "../rollback/rollbackManager.core.js";
 import { promptProjectName, promptProjectType, promptConfirmation, } from "../prompts/project/index.js";
@@ -31,7 +32,9 @@ const VALID_ARCHITECTURES = [
     "modular-monolith",
     "microservice",
 ];
-const VALID_DATABASES = ["postgresql", "mysql", "sqlite", "mongodb"];
+// No mongodb: there is no adapter for it, and it used to be accepted and
+// scaffolded as PostgreSQL (tooling/CLI-04).
+const VALID_DATABASES = ["postgresql", "mysql", "sqlite"];
 const VALID_PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
 const SERVICE_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 const VALID_FRONTENDS = [
@@ -285,6 +288,17 @@ export async function runCreateCommand(context) {
     if (!answers.projectName) {
         throw new CLIValidationError("Project name is required.");
     }
+    // Backend templates only emit TypeScript. `--language javascript` used to
+    // be accepted and ignored (tooling/CLI-09); in a fullstack project it
+    // applies to the frontend only, which is said out loud.
+    if (answers.language === "javascript") {
+        if (answers.projectType === "backend") {
+            throw new CLIValidationError("Backend projects are generated in TypeScript only; --language javascript is not supported for --type backend.");
+        }
+        if (answers.projectType === "fullstack") {
+            context.logger.warn("--language javascript applies to the frontend (apps/web) only; the backend is generated in TypeScript.");
+        }
+    }
     await createProject(answers, context);
 }
 async function createProject(options, context) {
@@ -453,12 +467,11 @@ async function generateFullstackProject(options, projectPath, rollback) {
     }
     // Uses the same BackendGenerator the generator registry exposes rather
     // than a third private copy of the architecture switch.
-    const backendFiles = await new BackendGenerator().generate(options, join(projectPath, "apps/api"));
-    // The backend template may carry its own workspace definition; nested in
-    // apps/api it would create a second workspace root, so strip it.
-    delete backendFiles["pnpm-workspace.yaml"];
-    await writeFileTree(join(projectPath, "apps/api"), backendFiles);
-    rollback.trackDirectory(join(projectPath, "apps/api"));
+    const backend = layoutFullstackBackend(options.architecture, await new BackendGenerator().generate(options, join(projectPath, "apps/api")));
+    await writeFileTree(join(projectPath, backend.directory), backend.files);
+    for (const directory of backend.createdDirectories) {
+        rollback.trackDirectory(join(projectPath, directory));
+    }
     const integrationGenerator = new IntegrationGenerator();
     await integrationGenerator.generate({
         project: {
@@ -492,6 +505,7 @@ async function generateFullstackProject(options, projectPath, rollback) {
         database: options.database ?? "postgresql",
         packageManager: options.packageManager,
         services: options.services,
+        appDirectory: "apps/api",
     }, projectPath);
 }
 async function generateFrontendProject(options, projectPath) {

package/dist/src/commands/generate.command.js

@@ -5,6 +5,7 @@
  * Reads the project manifest to determine the architecture and where the
  * backend lives, then places the schematic accordingly.
  */
+import { join } from "node:path";
 import { generateService } from "../generators/service/service.generator.js";
 import { generateModule } from "../generators/module/module.generator.js";
 import { generateCommand } from "../generators/command/command.generator.js";
@@ -21,6 +22,7 @@ import { generateValidator } from "../generators/validator/validator.generator.j
 import { CLIGenerationError, CLIValidationError } from "../errors/index.js";
 import { assertGeneratableName, assertSafePathSegment, } from "../utils/utils.name.js";
 import { resolveProjectLayout } from "../resolvers/layout/projectLayout.core.js";
+import { captureWrites, findWriteConflicts } from "../utils/utils.writeGuard.js";
 const VALID_SCHEMATICS = [
     "service",
     "module",
@@ -71,9 +73,14 @@ function getArchitectureRoot(architecture, schematic, serviceName) {
             }
             // `--service <name>` selects which app the schematic belongs to.
             // Without it the gateway app — the one app always generated — is used.
-            return serviceName !== undefined
-                ? `apps/services/${serviceName}/src`
-                : "apps/gateway/src";
+            // Modules go to that app's src/modules, next to the scaffolded ones,
+            // so they can be registered in its app.ts.
+            {
+                const appRoot = serviceName !== undefined
+                    ? `apps/services/${serviceName}/src`
+                    : "apps/gateway/src";
+                return schematic === "module" ? `${appRoot}/modules` : appRoot;
+            }
         case "monolith":
         default:
             if (schematic === "module") {
@@ -92,7 +99,11 @@ function getArchitectureRoot(architecture, schematic, serviceName) {
 function backendPrefix(cwd) {
     const layout = resolveProjectLayout(cwd);
     const [first] = layout?.backendDirs ?? [];
-    if (layout?.projectType === "fullstack" && first !== undefined && first !== cwd) {
+    // Only a monolith fullstack backend lives in apps/api; a microservice
+    // fullstack project keeps apps/gateway and apps/services at the root.
+    if (layout?.projectType === "fullstack" &&
+        first !== undefined &&
+        first === join(cwd, "apps", "api")) {
         return "apps/api/";
     }
     return "";
@@ -103,6 +114,7 @@ export async function runGenerateCommand(context) {
     const service = context.values.service;
     const moduleName = context.values.module;
     const dryRun = context.values["dry-run"] === true;
+    const force = context.values.force === true;
     if (!schematic ||
         !VALID_SCHEMATICS.includes(schematic)) {
         throw new CLIValidationError(`Schematic name is required. Available: ${VALID_SCHEMATICS.join(", ")}`);
@@ -137,11 +149,30 @@ export async function runGenerateCommand(context) {
     if (architecture === "modular-monolith" && schematic === "service") {
         context.logger.info('Mapping "service" → "module" for modular-monolith architecture.');
     }
-    const result = await runSchematic(schematic, name, {
+    const schematicOptions = {
         service,
         module: moduleName,
         dryRun,
         architecture: architecture ?? undefined,
+    };
+    if (!dryRun && !force) {
+        const planned = await captureWrites(() => runSchematic(schematic, name, schematicOptions, cwd));
+        const conflicts = findWriteConflicts(cwd, planned);
+        if (conflicts.length > 0) {
+            throw new CLIValidationError(`Refusing to overwrite existing files:\n${conflicts
+                .map((file) => `  - ${file}`)
+                .join("\n")}\nRe-run with --force to overwrite them.`);
+        }
+    }
+    const result = await runSchematic(schematic, name, {
+        ...schematicOptions,
+        onModuleRegistered: (registration) => {
+            if (registration.registered)
+                return;
+            context.logger.warn(`Could not register the module in app.ts automatically. Add:\n${registration.manualSteps
+                .map((step) => `  ${step}`)
+                .join("\n")}`);
+        },
     }, cwd);
     if (dryRun) {
         context.logger.info(`Dry run: ${result.length} files would be generated (nothing written):`);
@@ -167,7 +198,7 @@ async function runSchematic(schematic, name, options, cwd) {
             case "service":
                 return await generateService({ name, basePath, dryRun }, cwd);
             case "module":
-                return await generateModule({ name, feature: true, basePath, dryRun }, cwd);
+                return await generateModule({ name, feature: true, basePath, dryRun, onRegistered: options.onModuleRegistered }, cwd);
             case "command":
                 return await generateCommand({ name, ...(cqrsService ? { service: cqrsService } : {}), basePath, dryRun }, cwd);
             case "query":

package/dist/src/errors/index.d.ts

@@ -1,19 +1,8 @@
 /**
  * zudojs-cli — Errors
  *
- * Error classes for the CLI scaffolding system.
+ * Error classes for the CLI scaffolding system. They live in
+ * `@zudojs/errors` and are re-exported here for existing imports.
  */
-import { ApplicationError } from "@zudojs/errors";
-export declare class CLIValidationError extends ApplicationError {
-    constructor(message: string);
-}
-export declare class CLIGenerationError extends ApplicationError {
-    constructor(message: string, cause?: unknown);
-}
-export declare class CLINotInProjectError extends ApplicationError {
-    constructor();
-}
-export declare class CLITemplateError extends ApplicationError {
-    constructor(message: string);
-}
+export { CLIValidationError, CLIGenerationError, CLINotInProjectError, CLITemplateError, } from "@zudojs/errors";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/errors/index.js

@@ -1,29 +1,8 @@
 /**
  * zudojs-cli — Errors
  *
- * Error classes for the CLI scaffolding system.
+ * Error classes for the CLI scaffolding system. They live in
+ * `@zudojs/errors` and are re-exported here for existing imports.
  */
-import { ApplicationError } from "@zudojs/errors";
-export class CLIValidationError extends ApplicationError {
-    constructor(message) {
-        super(message, { isOperational: true });
-    }
-}
-export class CLIGenerationError extends ApplicationError {
-    constructor(message, cause) {
-        super(message, { cause });
-    }
-}
-export class CLINotInProjectError extends ApplicationError {
-    constructor() {
-        super("This command must be run inside a Zudojs project directory.", {
-            isOperational: true,
-        });
-    }
-}
-export class CLITemplateError extends ApplicationError {
-    constructor(message) {
-        super(message);
-    }
-}
+export { CLIValidationError, CLIGenerationError, CLINotInProjectError, CLITemplateError, } from "@zudojs/errors";
 //# sourceMappingURL=index.js.map

package/dist/src/generators/frontend/frontendPipeline.js

@@ -13,6 +13,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { writeFileTree } from "../../utils/utils.fileSystem.js";
+import { CLIGenerationError } from "../../errors/index.js";
 /**
  * Rejects package names a package manager would read as a flag.
  *
@@ -107,18 +108,21 @@ async function recordDependencies(projectPath, dependencies, devDependencies) {
     const pkgPath = join(projectPath, "package.json");
     let pkg = {};
     if (existsSync(pkgPath)) {
+        // Fail the scaffold rather than replace an unparsable package.json with
+        // one holding only dependencies: that silently dropped name, scripts and
+        // type (tooling/CLI-07).
         try {
             pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
         }
-        catch {
-            pkg = {};
+        catch (error) {
+            throw new CLIGenerationError(`Could not parse ${pkgPath}; refusing to overwrite it with only the resolved dependencies.`, error);
         }
     }
     const merge = (target, entries) => {
         const merged = { ...(target ?? {}) };
         for (const entry of entries) {
             if (!(entry.name in merged)) {
-                merged[entry.name] = entry.version || "latest";
+                merged[entry.name] = entry.version;
             }
         }
         return merged;

package/dist/src/generators/fullstack/fullstackBackend.layout.d.ts

@@ -0,0 +1,26 @@
+/**
+ * zudojs-cli — Where a fullstack project's backend files go.
+ *
+ * A monolith backend is a single app written to `apps/api`. A microservice
+ * backend is a set of apps, and nesting it under `apps/api` put the gateway
+ * and services at `apps/api/apps/*`, outside the root workspace globs, so
+ * their dependencies were never installed and the root docker-compose built
+ * directories holding only a Dockerfile. Its apps are written at the root
+ * instead (`apps/gateway`, `apps/services/<name>`), next to `apps/web`.
+ */
+/** Backend files and the directory they are written under. */
+export interface FullstackBackendLayout {
+    /** Directory relative to the project root ("" for the root). */
+    readonly directory: string;
+    /** Files relative to `directory`. */
+    readonly files: Record<string, string>;
+    /** Directories created, relative to the project root, for rollback. */
+    readonly createdDirectories: readonly string[];
+}
+/**
+ * Places generated backend files inside a fullstack project. Root-level
+ * files of a microservice backend (its own package.json, workspace file,
+ * compose file, README) are dropped: the fullstack root owns those.
+ */
+export declare function layoutFullstackBackend(architecture: string, backendFiles: Readonly<Record<string, string>>): FullstackBackendLayout;
+//# sourceMappingURL=fullstackBackend.layout.d.ts.map

package/dist/src/generators/fullstack/fullstackBackend.layout.js

@@ -0,0 +1,34 @@
+/**
+ * zudojs-cli — Where a fullstack project's backend files go.
+ *
+ * A monolith backend is a single app written to `apps/api`. A microservice
+ * backend is a set of apps, and nesting it under `apps/api` put the gateway
+ * and services at `apps/api/apps/*`, outside the root workspace globs, so
+ * their dependencies were never installed and the root docker-compose built
+ * directories holding only a Dockerfile. Its apps are written at the root
+ * instead (`apps/gateway`, `apps/services/<name>`), next to `apps/web`.
+ */
+/**
+ * Places generated backend files inside a fullstack project. Root-level
+ * files of a microservice backend (its own package.json, workspace file,
+ * compose file, README) are dropped: the fullstack root owns those.
+ */
+export function layoutFullstackBackend(architecture, backendFiles) {
+    if (architecture !== "microservice") {
+        const files = { ...backendFiles };
+        delete files["pnpm-workspace.yaml"];
+        return { directory: "apps/api", files, createdDirectories: ["apps/api"] };
+    }
+    const files = {};
+    for (const [path, content] of Object.entries(backendFiles)) {
+        if (path.startsWith("apps/gateway/") || path.startsWith("apps/services/")) {
+            files[path] = content;
+        }
+    }
+    return {
+        directory: "",
+        files,
+        createdDirectories: ["apps/gateway", "apps/services"],
+    };
+}
+//# sourceMappingURL=fullstackBackend.layout.js.map

package/dist/src/generators/fullstack/fullstackComposer.core.js

@@ -63,7 +63,11 @@ export class FullstackComposer {
     }
     async createWorkspace(context) {
         const packageManager = this.getPackageManager(context);
-        const workspaceGlobs = ["apps/*", "packages/*"];
+        // A microservice backend lives at apps/gateway and apps/services/<name>
+        // (tooling/CLI-02); `apps/*` alone does not reach the services.
+        const workspaceGlobs = context.project.backend?.architecture === "microservice"
+            ? ["apps/*", "apps/services/*", "packages/*"]
+            : ["apps/*", "packages/*"];
         const scriptFor = (script) => {
             switch (packageManager) {
                 case "npm":

package/dist/src/generators/fullstack/index.d.ts

@@ -4,4 +4,5 @@
  * Composes fullstack projects by orchestrating backend, frontend, and integration generators.
  */
 export { FullstackComposer } from "./fullstackComposer.core.js";
+export { layoutFullstackBackend, type FullstackBackendLayout, } from "./fullstackBackend.layout.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/generators/fullstack/index.js

@@ -4,4 +4,5 @@
  * Composes fullstack projects by orchestrating backend, frontend, and integration generators.
  */
 export { FullstackComposer } from "./fullstackComposer.core.js";
+export { layoutFullstackBackend, } from "./fullstackBackend.layout.js";
 //# sourceMappingURL=index.js.map

package/dist/src/generators/infrastructure/infrastructure.generator.d.ts

@@ -9,23 +9,18 @@ export interface InfrastructureOptions {
     readonly database: string;
     readonly packageManager: string;
     readonly services?: readonly string[];
+    /**
+     * Directory holding the non-microservice server, relative to the project
+     * root. The fullstack scaffold passes `"apps/api"`; defaults to `"."`.
+     */
+    readonly appDirectory?: string;
 }
 export declare class InfrastructureGenerator {
     generate(options: InfrastructureOptions, basePath: string): Promise<void>;
     private getFiles;
-    /**
-     * Install and build commands for Dockerfiles.
-     *
-     * Generated projects have no lockfile yet, so never use `npm ci` or
-     * `--frozen-lockfile`. pnpm and yarn need `corepack enable` on the bare
-     * node:24-alpine image; bun is not available there so it falls back to npm.
-     */
-    private getDockerCommands;
     private getDatabaseCompose;
     private getDatabaseUrl;
     private getDbServiceBlock;
-    private getAppDockerfile;
-    private getServiceDockerfile;
     private getSimpleDockerCompose;
     private getDockerCompose;
 }