zudojs-cli 1.2.1 → 2.0.1

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

@@ -19,25 +19,13 @@ import { generateRoute } from "../generators/route/route.generator.js";
 import { generateModel } from "../generators/model/model.generator.js";
 import { generateDto } from "../generators/dto/dto.generator.js";
 import { generateValidator } from "../generators/validator/validator.generator.js";
-import { CLIGenerationError, CLIValidationError } from "../errors/index.js";
+import { CLIGenerationError, CLINotInProjectError, CLIValidationError, } from "../errors/index.js";
 import { assertGeneratableName, assertSafePathSegment, } from "../utils/utils.name.js";
+import { SCHEMATIC_NAMES } from "../constants/index.js";
 import { resolveProjectLayout } from "../resolvers/layout/projectLayout.core.js";
+import { findProjectRoot } from "../resolvers/project.resolver.js";
+import { describeError } from "./commandError.helper.js";
 import { captureWrites, findWriteConflicts } from "../utils/utils.writeGuard.js";
-const VALID_SCHEMATICS = [
-    "service",
-    "module",
-    "command",
-    "query",
-    "controller",
-    "repository",
-    "middleware",
-    "event",
-    "job",
-    "route",
-    "model",
-    "dto",
-    "validator",
-];
 /**
  * Resolves the directory a schematic is generated into.
  *
@@ -86,6 +74,13 @@ function getArchitectureRoot(architecture, schematic, serviceName) {
             if (schematic === "module") {
                 return "src/modules";
             }
+            if (schematic === "service") {
+                // The monolith template scaffolds `src/services/app.service.ts` and a
+                // `src/services/index.ts` barrel. Generating into `src/<name>/`
+                // instead left two conventions in one project, and the generated
+                // service was never exported from the barrel the template owns.
+                return "src/services";
+            }
             return "src";
     }
 }
@@ -116,8 +111,8 @@ export async function runGenerateCommand(context) {
     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(", ")}`);
+        !SCHEMATIC_NAMES.includes(schematic)) {
+        throw new CLIValidationError(`Schematic name is required. Available: ${SCHEMATIC_NAMES.join(", ")}`);
     }
     if (!name) {
         throw new CLIValidationError("Resource name is required.");
@@ -133,20 +128,55 @@ export async function runGenerateCommand(context) {
     if (moduleName !== undefined) {
         assertSafePathSegment(moduleName, "--module");
     }
-    const cwd = context.cwd;
-    const layout = resolveProjectLayout(cwd);
+    // `generate` used to resolve the layout from the current directory only:
+    // from any subdirectory of a project it found nothing, warned, fell back
+    // to "src" and wrote a second tree (proj/src/src/foo/…) while exiting 0.
+    // It now walks up like `build` does, and refuses outside a project like
+    // `dev`, `build` and `add` do instead of scattering files into the cwd.
+    const projectRoot = findProjectRoot(context.cwd);
+    if (projectRoot === null) {
+        throw new CLINotInProjectError();
+    }
+    const cwd = projectRoot;
+    const layout = resolveProjectLayout(projectRoot);
     const architecture = layout?.architecture ?? null;
     if (layout) {
         context.logger.info(`Detected architecture: ${layout.architecture}`);
     }
-    else {
-        context.logger.warn("No Zudojs project detected (no .zudojs/manifest.json, zudojs.config.ts " +
-            "or `zudojs` field in package.json). Run `zudojs create` first.");
+    if (projectRoot !== context.cwd) {
+        context.logger.info(`Project root: ${projectRoot}`);
     }
+    /**
+     * A microservice's service is a whole workspace app — `package.json`,
+     * `tsconfig.json`, `Dockerfile`, `src/app.ts`, `src/server.ts` and a port —
+     * which this schematic does not produce.
+     *
+     * It used to warn and continue, writing a bare service class into
+     * `apps/services/<name>/`. That directory matches the workspace glob but has
+     * no manifest, so pnpm skipped it, `pnpm -r run build` never compiled it,
+     * and `zudojs add --service <name>` reported it as an unknown service. The
+     * files were unreachable and the command still exited 0. Refusing with the
+     * two commands that do work is more useful than dead code.
+     */
     if (architecture === "microservice" && schematic === "service") {
-        context.logger.warn('In microservice architecture, prefer "zudojs generate module" — services are top-level apps.');
+        throw new CLIValidationError(`A service in a microservice project is a workspace app, which "generate service" does not scaffold.\n` +
+            `  - Add it at creation time:  zudojs create <project> --architecture microservice --services ${name}\n` +
+            `  - Or add a module to an existing app:  zudojs generate module ${name} --service <existing-service>`);
     }
-    if (architecture === "modular-monolith" && schematic === "service") {
+    /**
+     * A modular monolith has modules, not services, so `generate service` means
+     * `generate module` there.
+     *
+     * This used to log the mapping and then run the service schematic anyway,
+     * which wrote four inert files into a new top-level directory that the
+     * runtime never loads. Rewriting the schematic here — rather than at the
+     * dispatch switch — keeps the base-path resolution, the overwrite guard and
+     * the result message all describing the same thing.
+     */
+    const effectiveSchematic = architecture === "modular-monolith" && schematic === "service"
+        ? "module"
+        : schematic;
+    if (effectiveSchematic !== schematic) {
         context.logger.info('Mapping "service" → "module" for modular-monolith architecture.');
     }
     const schematicOptions = {
@@ -156,7 +186,7 @@ export async function runGenerateCommand(context) {
         architecture: architecture ?? undefined,
     };
     if (!dryRun && !force) {
-        const planned = await captureWrites(() => runSchematic(schematic, name, schematicOptions, cwd));
+        const planned = await captureWrites(() => runSchematic(effectiveSchematic, name, schematicOptions, cwd));
         const conflicts = findWriteConflicts(cwd, planned);
         if (conflicts.length > 0) {
             throw new CLIValidationError(`Refusing to overwrite existing files:\n${conflicts
@@ -164,7 +194,7 @@ export async function runGenerateCommand(context) {
                 .join("\n")}\nRe-run with --force to overwrite them.`);
         }
     }
-    const result = await runSchematic(schematic, name, {
+    const result = await runSchematic(effectiveSchematic, name, {
         ...schematicOptions,
         onModuleRegistered: (registration) => {
             if (registration.registered)
@@ -191,9 +221,15 @@ async function runSchematic(schematic, name, options, cwd) {
         const dryRun = options.dryRun;
         // In the microservice layout `--service` selected the owning app and is
         // already part of basePath, so it must not nest the schematic again.
-        const cqrsService = options.architecture === "microservice"
-            ? undefined
-            : (options.service ?? "default");
+        //
+        // Without `--service` there is no CQRS group at all. This used to fall
+        // back to the literal `"default"`, which became a path segment no template
+        // ever creates: `zudojs generate command pay` wrote `src/default/commands/`,
+        // and with `--module identity` it wrote `src/modules/identity/default/`
+        // right next to the real, empty `src/modules/identity/commands/`. Nothing
+        // imported either. The generators already handle an absent group by
+        // writing to `<basePath>/commands/<name>`.
+        const cqrsService = options.architecture === "microservice" ? undefined : options.service;
         switch (schematic) {
             case "service":
                 return await generateService({ name, basePath, dryRun }, cwd);
@@ -222,11 +258,14 @@ async function runSchematic(schematic, name, options, cwd) {
             case "validator":
                 return await generateValidator({ name, basePath, dryRun }, cwd);
             default:
-                throw new CLIValidationError(`Unknown schematic: "${schematic}". Available: ${VALID_SCHEMATICS.join(", ")}.`);
+                throw new CLIValidationError(`Unknown schematic: "${schematic}". Available: ${SCHEMATIC_NAMES.join(", ")}.`);
         }
     }
     catch (error) {
-        throw new CLIGenerationError(`Failed to generate ${schematic}: ${name}`, error);
+        // The cause was attached but never rendered, so an ENOTDIR or EACCES
+        // surfaced as a bare "Failed to generate service: billing" with no way
+        // to find out more. `build` and `add` interpolate it; so does this.
+        throw new CLIGenerationError(`Failed to generate ${schematic} "${name}": ${describeError(error)}`, error);
     }
 }
 //# sourceMappingURL=generate.command.js.map

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

@@ -3,6 +3,7 @@
  *
  * Constants used by the CLI scaffolding system.
  */
+import type { BackendArchitecture, DatabaseProvider, PackageManagerType } from "../types/projectConfiguration.type.js";
 export { CLI_VERSION } from "../cliConstant/cliVersion.js";
 /**
  * Version range every generated project depends on for `@zudojs/*` packages.
@@ -22,74 +23,45 @@ export declare const ZUDOJS_PACKAGES_VERSION: "^1.0.0";
  * project is backed by its package.
  */
 export declare const FEATURE_PACKAGES: Readonly<Record<string, readonly string[]>>;
-export declare const ARCHITECTURE_CHOICES: readonly [{
-    readonly value: "monolith";
-    readonly label: "Monolith";
-}, {
-    readonly value: "modular-monolith";
-    readonly label: "Modular Monolith";
-}, {
-    readonly value: "microservice";
-    readonly label: "Microservice";
-}];
-export declare const PACKAGE_MANAGER_CHOICES: readonly [{
-    readonly value: "pnpm";
-    readonly label: "pnpm";
-}, {
-    readonly value: "npm";
-    readonly label: "npm";
-}, {
-    readonly value: "yarn";
-    readonly label: "yarn";
-}];
-export declare const DATABASE_CHOICES: readonly [{
-    readonly value: "postgresql";
-    readonly label: "PostgreSQL";
-}, {
-    readonly value: "mysql";
-    readonly label: "MySQL";
-}, {
-    readonly value: "sqlite";
-    readonly label: "SQLite";
-}];
-export declare const FEATURE_CHOICES: readonly [{
-    readonly value: "database";
-    readonly label: "Database";
-}, {
-    readonly value: "queue";
-    readonly label: "Queue";
-}, {
-    readonly value: "messaging";
-    readonly label: "Messaging";
-}, {
-    readonly value: "openapi";
-    readonly label: "OpenAPI";
-}, {
-    readonly value: "observability";
-    readonly label: "Observability";
-}, {
-    readonly value: "security";
-    readonly label: "Security";
-}];
-export declare const SCHEMA_CHOICES: readonly [{
-    readonly value: "service";
-    readonly label: "Service (CQRS)";
-}, {
-    readonly value: "module";
-    readonly label: "Module";
-}, {
-    readonly value: "command";
-    readonly label: "Command";
-}, {
-    readonly value: "query";
-    readonly label: "Query";
-}, {
-    readonly value: "controller";
-    readonly label: "Controller";
-}, {
-    readonly value: "repository";
-    readonly label: "Repository";
-}];
+/** A selectable answer offered by a prompt. */
+export interface CLIChoiceOption<Value extends string = string> {
+    readonly value: Value;
+    readonly label: string;
+    readonly hint?: string;
+}
+/** Backend architectures offered by `zudojs create`. */
+export declare const ARCHITECTURE_CHOICES: readonly CLIChoiceOption<BackendArchitecture>[];
+/**
+ * The package managers the CLI can install with.
+ *
+ * One canonical list. It previously existed three times — as
+ * `VALID_PACKAGE_MANAGERS` in the create command, `PACKAGE_MANAGERS` in the
+ * layout resolver and `SUPPORTED_MANAGERS` in the package-manager runner —
+ * which is how `bun` came to be missing from the published choice list while
+ * the CLI supported it everywhere else.
+ */
+export declare const PACKAGE_MANAGERS: readonly PackageManagerType[];
+/** Package managers the CLI can install with, as prompt choices. */
+export declare const PACKAGE_MANAGER_CHOICES: readonly CLIChoiceOption<PackageManagerType>[];
+/** Database engines the CLI has adapters for. */
+export declare const DATABASE_CHOICES: readonly CLIChoiceOption<DatabaseProvider>[];
+/**
+ * Features `zudojs add` accepts.
+ *
+ * Derived from `FEATURE_PACKAGES` so the two cannot drift: the hand-written
+ * list named six of the ten installable features.
+ */
+export declare const FEATURE_CHOICES: readonly CLIChoiceOption[];
+/**
+ * Schematics `zudojs generate` accepts, in the order the help lists them.
+ *
+ * This is the canonical list; the hand-written one named six of thirteen.
+ */
+export declare const SCHEMA_CHOICES: readonly CLIChoiceOption[];
+/** Names only, for help text and validation messages. */
+export declare const SCHEMATIC_NAMES: readonly string[];
+/** Feature names only, for help text and validation messages. */
+export declare const FEATURE_NAMES: readonly string[];
 export declare const DEFAULT_ARCHITECTURE: "monolith";
 export declare const DEFAULT_PACKAGE_MANAGER: "pnpm";
 export declare const DEFAULT_DATABASE: "postgresql";

package/dist/src/constants/index.js

@@ -35,37 +35,87 @@ export const FEATURE_PACKAGES = {
     scheduler: ["@zudojs/scheduler"],
     docs: ["@zudojs/docs"],
 };
-export const ARCHITECTURE_CHOICES = [
-    { value: "monolith", label: "Monolith" },
-    { value: "modular-monolith", label: "Modular Monolith" },
-    { value: "microservice", label: "Microservice" },
-];
-export const PACKAGE_MANAGER_CHOICES = [
+/** Backend architectures offered by `zudojs create`. */
+export const ARCHITECTURE_CHOICES = Object.freeze([
+    { value: "monolith", label: "Monolith", hint: "Single application" },
+    {
+        value: "modular-monolith",
+        label: "Modular Monolith",
+        hint: "Modular single application",
+    },
+    {
+        value: "microservice",
+        label: "Microservices",
+        hint: "Independent services",
+    },
+]);
+/**
+ * The package managers the CLI can install with.
+ *
+ * One canonical list. It previously existed three times — as
+ * `VALID_PACKAGE_MANAGERS` in the create command, `PACKAGE_MANAGERS` in the
+ * layout resolver and `SUPPORTED_MANAGERS` in the package-manager runner —
+ * which is how `bun` came to be missing from the published choice list while
+ * the CLI supported it everywhere else.
+ */
+export const PACKAGE_MANAGERS = Object.freeze([
+    "pnpm",
+    "npm",
+    "yarn",
+    "bun",
+]);
+/** Package managers the CLI can install with, as prompt choices. */
+export const PACKAGE_MANAGER_CHOICES = Object.freeze([
     { value: "pnpm", label: "pnpm" },
     { value: "npm", label: "npm" },
-    { value: "yarn", label: "yarn" },
-];
-export const DATABASE_CHOICES = [
-    { value: "postgresql", label: "PostgreSQL" },
-    { value: "mysql", label: "MySQL" },
-    { value: "sqlite", label: "SQLite" },
-];
-export const FEATURE_CHOICES = [
-    { value: "database", label: "Database" },
-    { value: "queue", label: "Queue" },
-    { value: "messaging", label: "Messaging" },
-    { value: "openapi", label: "OpenAPI" },
-    { value: "observability", label: "Observability" },
-    { value: "security", label: "Security" },
-];
-export const SCHEMA_CHOICES = [
+    { value: "yarn", label: "Yarn" },
+    { value: "bun", label: "Bun" },
+]);
+/** Database engines the CLI has adapters for. */
+export const DATABASE_CHOICES = Object.freeze([
+    {
+        value: "postgresql",
+        label: "PostgreSQL",
+        hint: "Recommended for production",
+    },
+    {
+        value: "mysql",
+        label: "MySQL",
+        hint: "Widely used relational database",
+    },
+    { value: "sqlite", label: "SQLite", hint: "Lightweight, file-based" },
+]);
+/**
+ * Features `zudojs add` accepts.
+ *
+ * Derived from `FEATURE_PACKAGES` so the two cannot drift: the hand-written
+ * list named six of the ten installable features.
+ */
+export const FEATURE_CHOICES = Object.freeze(Object.keys(FEATURE_PACKAGES).map((value) => Object.freeze({ value, label: value })));
+/**
+ * Schematics `zudojs generate` accepts, in the order the help lists them.
+ *
+ * This is the canonical list; the hand-written one named six of thirteen.
+ */
+export const SCHEMA_CHOICES = Object.freeze([
     { value: "service", label: "Service (CQRS)" },
     { value: "module", label: "Module" },
     { value: "command", label: "Command" },
     { value: "query", label: "Query" },
     { value: "controller", label: "Controller" },
     { value: "repository", label: "Repository" },
-];
+    { value: "middleware", label: "Middleware" },
+    { value: "event", label: "Event" },
+    { value: "job", label: "Job" },
+    { value: "route", label: "Route" },
+    { value: "model", label: "Model" },
+    { value: "dto", label: "DTO" },
+    { value: "validator", label: "Validator" },
+]);
+/** Names only, for help text and validation messages. */
+export const SCHEMATIC_NAMES = Object.freeze(SCHEMA_CHOICES.map((choice) => choice.value));
+/** Feature names only, for help text and validation messages. */
+export const FEATURE_NAMES = Object.freeze(FEATURE_CHOICES.map((choice) => choice.value));
 export const DEFAULT_ARCHITECTURE = "monolith";
 export const DEFAULT_PACKAGE_MANAGER = "pnpm";
 export const DEFAULT_DATABASE = "postgresql";

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

@@ -67,6 +67,13 @@ export async function runFrontendPipeline(adapter, context, packageManagerRegist
         }
         return { files, errors };
     }
+    // The resolver records a warning for every dependency it could not pin,
+    // which then goes into package.json as "latest". Nothing read that array,
+    // so an adapter adding a dependency with no registered range silently made
+    // the generated project unreproducible.
+    for (const warning of resolution.warnings) {
+        process.stderr.write(`warning: ${warning}\n`);
+    }
     // 5. Install BOTH runtime and dev dependencies. Only devDependencies used
     //    to be installed, so every runtime package an adapter declared was
     //    resolved and then dropped on the floor. With `--no-install` the
@@ -77,10 +84,15 @@ export async function runFrontendPipeline(adapter, context, packageManagerRegist
         files.push("dependencies");
     }
     else if (packageManager) {
-        const deps = resolution.dependencies.map((d) => d.name);
-        const devDeps = resolution.devDependencies.map((d) => d.name);
-        assertSafePackageNames(deps);
-        assertSafePackageNames(devDeps);
+        // Install the resolved RANGE, not just the name. Mapping to names alone
+        // let npm/pnpm resolve `latest`, so the pinning the resolver exists to
+        // provide survived only on the `--no-install` path and two runs a month
+        // apart produced different majors. The names are validated separately
+        // from the `name@range` specs actually passed to the package manager.
+        assertSafePackageNames(resolution.dependencies.map((d) => d.name));
+        assertSafePackageNames(resolution.devDependencies.map((d) => d.name));
+        const deps = resolution.dependencies.map((d) => `${d.name}@${d.version}`);
+        const devDeps = resolution.devDependencies.map((d) => `${d.name}@${d.version}`);
         if (deps.length > 0) {
             await packageManager.add(context.projectPath, deps);
         }

package/dist/src/generators/integration/integrationGenerator.core.js

@@ -5,7 +5,7 @@
  */
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { writeFileTree } from "../../utils/utils.fileSystem.js";
+import { mergeBarrelExport, writeFileTree, } from "../../utils/utils.fileSystem.js";
 import { renderDatabaseEnv } from "../../adapters/databases/databaseAdapter.resolver.js";
 /**
  * Generates integration files between frontend and backend.
@@ -24,11 +24,15 @@ export class IntegrationGenerator {
             const apiPath = this.getApiClientPath(context);
             files[apiPath] = apiClient;
         }
-        // CORS configuration, written next to the backend it configures. In a
-        // fullstack workspace the backend lives in apps/api; writing it at the
-        // workspace root left it where nothing could import it.
-        files[`${this.getBackendPath(context)}config/cors.ts`] =
-            this.generateCorsConfig(context);
+        // CORS configuration, written inside the backend's own program. The
+        // backend tsconfig sets `rootDir: "src"` and `include: ["src/**/*"]`, so
+        // a `config/` directory beside it is excluded from compilation and cannot
+        // be imported from `src/` without leaving rootDir. The templates' config
+        // directory is `src/configs/`, and its barrel is where the rest of the
+        // app looks for configuration.
+        const configDir = `${this.getBackendPath(context)}src/configs`;
+        files[`${configDir}/cors.ts`] = this.generateCorsConfig(context);
+        files[`${configDir}/index.ts`] = mergeBarrelExport(context.projectPath, `${configDir}/index.ts`, `export { corsConfig } from "./cors.js";`);
         // Development proxy configuration (belongs to the frontend app). The
         // frontend adapter has already written a vite.config.ts carrying the
         // framework plugin and path aliases; overwriting it with this minimal

package/dist/src/generators/project/project.generator.js

@@ -31,7 +31,11 @@ export async function generateProject(options, basePath = ".") {
         await writeFileTree(projectPath, templateFiles);
     }
     catch (error) {
-        throw new CLIGenerationError(`Failed to write project files:`, error);
+        // This message is what the user sees at the moment the CLI rolls back and
+        // deletes the directory it created, so it has to say why. It used to end
+        // in a colon with the cause never rendered.
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new CLIGenerationError(`Failed to write project files into ${projectPath}: ${reason}`, error);
     }
     const filesCreated = Object.keys(templateFiles);
     // Note: git initialization and dependency installation are orchestrated by

package/dist/src/index.d.ts

@@ -49,10 +49,10 @@ export { FullstackComposer } from "./generators/fullstack/index.js";
 export { IntegrationGenerator } from "./generators/integration/index.js";
 export { InfrastructureGenerator, type InfrastructureOptions, } from "./generators/infrastructure/index.js";
 export { ProcessRunner, type ProcessOptions } from "./runners/process/index.js";
-export { PackageManagerRunner, type PackageManagerRunOptions, } from "./runners/package-manager/index.js";
-export { TaskRunner, type TaskDefinition, type TaskResult, } from "./runners/task/index.js";
-export { RollbackManager, type RollbackEntry } from "./rollback/index.js";
-export { ManifestManager, type ZudojsManifest } from "./manifest/index.js";
+export { PackageManagerRunner, assertPackageManager, type PackageManagerRunOptions, } from "./runners/package-manager/index.js";
+export { TaskRunner, type TaskDefinition, type TaskResult, type TaskRunOptions, } from "./runners/task/index.js";
+export { RollbackManager, type RollbackEntry, type RollbackFailure, type RollbackResult, } from "./rollback/index.js";
+export { ManifestManager, parseManifest, type ManifestReadResult, type ManifestReadStatus, type ZudojsManifest, } from "./manifest/index.js";
 export type { ProjectConfiguration, ProjectType, BackendArchitecture, FrontendFramework, FrontendArchitecture, DatabaseProvider, ApiStyle, PackageManagerType, } from "./types/projectConfiguration.type.js";
 export type { ScaffoldOptions, ArchitectureType, PackageManager, DatabaseEngine, ProjectTemplate, GenerateOptions, } from "./types/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -58,10 +58,10 @@ export { IntegrationGenerator } from "./generators/integration/index.js";
 export { InfrastructureGenerator, } from "./generators/infrastructure/index.js";
 // Runners
 export { ProcessRunner } from "./runners/process/index.js";
-export { PackageManagerRunner, } from "./runners/package-manager/index.js";
+export { PackageManagerRunner, assertPackageManager, } from "./runners/package-manager/index.js";
 export { TaskRunner, } from "./runners/task/index.js";
 // Rollback
-export { RollbackManager } from "./rollback/index.js";
+export { RollbackManager, } from "./rollback/index.js";
 // Manifest
-export { ManifestManager } from "./manifest/index.js";
+export { ManifestManager, parseManifest, } from "./manifest/index.js";
 //# sourceMappingURL=index.js.map

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

@@ -4,4 +4,5 @@
  * Manifest system barrel exports.
  */
 export { ManifestManager, type ZudojsManifest, } from "./manifestManager.core.js";
+export { parseManifest, type ManifestReadResult, type ManifestReadStatus, } from "./manifestFile.helper.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/manifest/index.js

@@ -4,4 +4,5 @@
  * Manifest system barrel exports.
  */
 export { ManifestManager, } from "./manifestManager.core.js";
+export { parseManifest, } from "./manifestFile.helper.js";
 //# sourceMappingURL=index.js.map

package/dist/src/manifest/manifestFile.helper.d.ts

@@ -0,0 +1,42 @@
+/**
+ * zudojs-cli — Manifest File Helpers
+ *
+ * Parsing, validation, atomic writes and locking for
+ * `.zudojs/manifest.json`. Kept apart from the manager so the manager stays
+ * a thin read/modify/write API over them.
+ */
+import type { ZudojsManifest } from "./manifestManager.core.js";
+/** How a manifest read turned out. */
+export type ManifestReadStatus = "ok" | "missing" | "invalid";
+/** The outcome of reading a manifest, with missing and corrupt kept apart. */
+export interface ManifestReadResult {
+    readonly status: ManifestReadStatus;
+    readonly manifest: ZudojsManifest | null;
+    /** Why an `invalid` manifest could not be used. */
+    readonly reason?: string;
+}
+/**
+ * Parses manifest text, filling in the fields an older CLI (or a hand edit)
+ * may have left out.
+ *
+ * `capabilities` used to be read straight off an unvalidated cast, so a
+ * manifest without it threw a TypeError from inside `addCapability`.
+ */
+export declare function parseManifest(content: string): ManifestReadResult;
+/**
+ * Writes the manifest through a sibling temp file and `rename`.
+ *
+ * Writing in place truncated the real file first, so an interrupted or
+ * failing write left an empty or half-written manifest behind.
+ */
+export declare function writeManifestFile(manifestPath: string, manifest: ZudojsManifest): Promise<void>;
+/**
+ * Serializes a read-modify-write of one manifest.
+ *
+ * Concurrent `zudojs add` runs lost each other's updates: each read the
+ * manifest, added its own capability and wrote the whole file back. The
+ * queue orders calls inside one process and the lock file orders them
+ * across processes.
+ */
+export declare function withManifestLock<T>(manifestPath: string, operation: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=manifestFile.helper.d.ts.map