zudojs-cli 2.0.1 → 2.1.1

package/dist/src/recipes/apply/recipeApply.files.js

@@ -0,0 +1,84 @@
+/**
+ * zudojs-cli — Edits `add` makes to plain project files: `.env.example`,
+ * `.gitignore`, `package.json` and `pnpm-workspace.yaml`. Every edit is
+ * additive and idempotent; existing values are never replaced (except the
+ * scripts a recipe names explicitly, and only from their generated value).
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { renderEnvVariables } from "../../templates/backendApp/index.js";
+/** `.env.example` with the variables it does not declare yet appended. */
+export function withEnvVariables(current, variables) {
+    const declared = new Set(current.split("\n").map((line) => line.split("=")[0]?.trim() ?? ""));
+    const missing = variables.filter((v) => !declared.has(v.name));
+    if (missing.length === 0)
+        return undefined;
+    const separator = current === "" || current.endsWith("\n") ? "" : "\n";
+    return `${current}${separator}${renderEnvVariables(missing)}\n`;
+}
+/** `.gitignore` with the lines it lacks appended. */
+export function withGitignoreLines(current, lines) {
+    const present = new Set(current.split("\n").map((line) => line.trim()));
+    const missing = lines.filter((line) => !present.has(line));
+    if (missing.length === 0)
+        return undefined;
+    const separator = current === "" || current.endsWith("\n") ? "" : "\n";
+    return `${current}${separator}${missing.join("\n")}\n`;
+}
+/** Merges `changes` into `pkg` in place. */
+export function mergePackageJson(pkg, changes) {
+    pkg.dependencies ??= {};
+    for (const [name, range] of Object.entries(changes.dependencies)) {
+        if (!(name in pkg.dependencies))
+            pkg.dependencies[name] = range;
+    }
+    if (changes.devDependencies !== undefined) {
+        pkg.devDependencies ??= {};
+        for (const [name, range] of Object.entries(changes.devDependencies)) {
+            if (!(name in pkg.devDependencies) && !(name in pkg.dependencies)) {
+                pkg.devDependencies[name] = range;
+            }
+        }
+    }
+    if (changes.scripts !== undefined || changes.replaceScripts !== undefined) {
+        pkg.scripts ??= {};
+        for (const [name, command] of Object.entries(changes.scripts ?? {})) {
+            if (!(name in pkg.scripts))
+                pkg.scripts[name] = command;
+        }
+        for (const [name, { from, to }] of Object.entries(changes.replaceScripts ?? {})) {
+            if (pkg.scripts[name] === from)
+                pkg.scripts[name] = to;
+        }
+    }
+    pkg.zudojs ??= {};
+    const block = pkg.zudojs;
+    const features = new Set(Array.isArray(block.features)
+        ? block.features.filter((f) => typeof f === "string")
+        : []);
+    features.add(changes.feature);
+    block.features = [...features];
+}
+/**
+ * `pnpm-workspace.yaml` with `names` added to both build-script allow-lists
+ * (pnpm 10 `onlyBuiltDependencies`, pnpm 11 `allowBuilds`). Returns
+ * `undefined` when there is no such file or nothing to add.
+ */
+export function withAllowedBuilds(root, names) {
+    const path = join(root, "pnpm-workspace.yaml");
+    if (names.length === 0 || !existsSync(path))
+        return undefined;
+    let source = readFileSync(path, "utf-8");
+    const original = source;
+    for (const name of names) {
+        const quoted = JSON.stringify(name);
+        if (/^onlyBuiltDependencies:\s*$/m.test(source) && !source.includes(`  - ${quoted}`)) {
+            source = source.replace(/^onlyBuiltDependencies:\s*$/m, `onlyBuiltDependencies:\n  - ${quoted}`);
+        }
+        if (/^allowBuilds:\s*$/m.test(source) && !source.includes(`  ${quoted}: true`)) {
+            source = source.replace(/^allowBuilds:\s*$/m, `allowBuilds:\n  ${quoted}: true`);
+        }
+    }
+    return source === original ? undefined : source;
+}
+//# sourceMappingURL=recipeApply.files.js.map

package/dist/src/recipes/apply/recipeApply.project.d.ts

@@ -0,0 +1,11 @@
+/**
+ * zudojs-cli — Project-level parts of `add`: project recipes (docker),
+ * `.gitignore` lines and the pnpm build-script allow-list.
+ */
+import type { ProjectRecipe, ProjectRecipeContext } from "../recipe.type.js";
+import type { RecipeOutcome } from "./recipeApply.app.js";
+/** Writes a project recipe's files (keeping existing ones) and env. */
+export declare function applyProjectRecipe(recipe: ProjectRecipe, context: ProjectRecipeContext): Promise<RecipeOutcome>;
+/** Appends `.gitignore` lines and pnpm allow-list entries; returns the files changed. */
+export declare function applyProjectSettings(root: string, gitignore: readonly string[], allowBuilds: readonly string[]): Promise<readonly string[]>;
+//# sourceMappingURL=recipeApply.project.d.ts.map

package/dist/src/recipes/apply/recipeApply.project.js

@@ -0,0 +1,50 @@
+/**
+ * zudojs-cli — Project-level parts of `add`: project recipes (docker),
+ * `.gitignore` lines and the pnpm build-script allow-list.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFile } from "../../utils/utils.fileSystem.js";
+import { withAllowedBuilds, withEnvVariables, withGitignoreLines } from "./recipeApply.files.js";
+/** Writes a project recipe's files (keeping existing ones) and env. */
+export async function applyProjectRecipe(recipe, context) {
+    const written = [];
+    const kept = [];
+    const edited = [];
+    for (const [path, content] of Object.entries(recipe.files(context))) {
+        if (existsSync(join(context.root, path))) {
+            kept.push(path);
+        }
+        else {
+            await writeFile(context.root, path, content);
+            written.push(path);
+        }
+    }
+    const env = recipe.env?.(context) ?? [];
+    if (env.length > 0) {
+        const path = join(context.root, ".env.example");
+        const next = withEnvVariables(existsSync(path) ? readFileSync(path, "utf-8") : "", env);
+        if (next !== undefined) {
+            await writeFile(context.root, ".env.example", next);
+            edited.push(".env.example");
+        }
+    }
+    return { written, kept, edited, manualSteps: [] };
+}
+/** Appends `.gitignore` lines and pnpm allow-list entries; returns the files changed. */
+export async function applyProjectSettings(root, gitignore, allowBuilds) {
+    const edited = [];
+    const ignorePath = join(root, ".gitignore");
+    const ignore = withGitignoreLines(existsSync(ignorePath) ? readFileSync(ignorePath, "utf-8") : "", gitignore);
+    if (ignore !== undefined) {
+        await writeFile(root, ".gitignore", ignore);
+        edited.push(".gitignore");
+    }
+    const workspace = withAllowedBuilds(root, allowBuilds);
+    if (workspace !== undefined) {
+        await writeFile(root, "pnpm-workspace.yaml", workspace);
+        edited.push("pnpm-workspace.yaml");
+    }
+    return edited;
+}
+//# sourceMappingURL=recipeApply.project.js.map

package/dist/src/recipes/apply/recipeApply.report.d.ts

@@ -0,0 +1,20 @@
+/**
+ * zudojs-cli — Recording a feature and reporting what `add` did.
+ */
+import type { CLIContext } from "../../cliType/cliType.type.js";
+import type { RecipeOutcome } from "./recipeApply.app.js";
+/** Adds `feature` to an app's `zudojs.features`. */
+export declare function recordFeature(pkgPath: string, feature: string): void;
+/**
+ * Adds `feature` to the workspace root's `zudojs.features` when the root is
+ * not itself an app that received it.
+ *
+ * A microservice root records the project's capabilities next to the
+ * manifest, but `add` only wrote the apps, so the root list went stale
+ * after the first `zudojs add`. Roots without a features list (fullstack)
+ * are left alone. Returns whether the root was updated.
+ */
+export declare function recordProjectFeature(root: string, feature: string, targets: readonly string[]): boolean;
+/** Logs what was written, kept, edited and what is left to do by hand. */
+export declare function reportOutcomes(logger: CLIContext["logger"], cwd: string, root: string, outcomes: readonly RecipeOutcome[]): void;
+//# sourceMappingURL=recipeApply.report.d.ts.map

package/dist/src/recipes/apply/recipeApply.report.js

@@ -0,0 +1,51 @@
+/**
+ * zudojs-cli — Recording a feature and reporting what `add` did.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { mergePackageJson } from "./recipeApply.files.js";
+/** Adds `feature` to an app's `zudojs.features`. */
+export function recordFeature(pkgPath, feature) {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    mergePackageJson(pkg, { feature, dependencies: {} });
+    writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+}
+/**
+ * Adds `feature` to the workspace root's `zudojs.features` when the root is
+ * not itself an app that received it.
+ *
+ * A microservice root records the project's capabilities next to the
+ * manifest, but `add` only wrote the apps, so the root list went stale
+ * after the first `zudojs add`. Roots without a features list (fullstack)
+ * are left alone. Returns whether the root was updated.
+ */
+export function recordProjectFeature(root, feature, targets) {
+    const pkgPath = join(root, "package.json");
+    if (!existsSync(pkgPath) || targets.includes(pkgPath))
+        return false;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const block = pkg.zudojs;
+    if (!Array.isArray(block?.features) || block.features.includes(feature))
+        return false;
+    block.features = [...block.features, feature];
+    writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+    return true;
+}
+/** Logs what was written, kept, edited and what is left to do by hand. */
+export function reportOutcomes(logger, cwd, root, outcomes) {
+    const rel = (path) => relative(cwd, join(root, path)) || path;
+    const list = (label, paths) => {
+        const unique = [...new Set(paths)];
+        if (unique.length === 0)
+            return;
+        logger.info(`${label}:\n${unique.map((p) => `  - ${rel(p)}`).join("\n")}`);
+    };
+    list("Created", outcomes.flatMap((o) => o.written));
+    list("Updated", outcomes.flatMap((o) => o.edited));
+    list("Kept (already present)", outcomes.flatMap((o) => o.kept));
+    const manual = outcomes.flatMap((o) => o.manualSteps);
+    if (manual.length > 0) {
+        logger.warn(`Finish by hand:\n${manual.map((step) => `  - ${step}`).join("\n")}`);
+    }
+}
+//# sourceMappingURL=recipeApply.report.js.map

package/dist/src/recipes/catalog/database/database.files.d.ts

@@ -0,0 +1,15 @@
+/**
+ * zudojs-cli — Files of the Prisma database recipe.
+ *
+ * Prisma 7: the `prisma-client` generator writes a TypeScript client into
+ * `src/generated/prisma` (ESM, `.js` import extensions, so `tsc` compiles
+ * it with the app), the connection URL lives in `prisma.config.ts`, and
+ * the client connects through the `@prisma/adapter-pg` driver adapter.
+ */
+/** `prisma/schema.prisma`. */
+export declare function renderPrismaSchema(): string;
+/** `prisma.config.ts`: reads DATABASE_URL from the environment or `.env`. */
+export declare function renderPrismaConfig(): string;
+/** `src/integrations/database.ts`. */
+export declare function renderDatabaseIntegration(): string;
+//# sourceMappingURL=database.files.d.ts.map

package/dist/src/recipes/catalog/database/database.files.js

@@ -0,0 +1,98 @@
+/**
+ * zudojs-cli — Files of the Prisma database recipe.
+ *
+ * Prisma 7: the `prisma-client` generator writes a TypeScript client into
+ * `src/generated/prisma` (ESM, `.js` import extensions, so `tsc` compiles
+ * it with the app), the connection URL lives in `prisma.config.ts`, and
+ * the client connects through the `@prisma/adapter-pg` driver adapter.
+ */
+/** `prisma/schema.prisma`. */
+export function renderPrismaSchema() {
+    return `// Prisma schema: https://www.prisma.io/docs/orm/prisma-schema
+// \`zudojs generate resource <name>\` appends a model here.
+
+generator client {
+  provider            = "prisma-client"
+  output              = "../src/generated/prisma"
+  moduleFormat        = "esm"
+  importFileExtension = "js"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+`;
+}
+/** `prisma.config.ts`: reads DATABASE_URL from the environment or `.env`. */
+export function renderPrismaConfig() {
+    return `import { defineConfig } from "prisma/config";
+
+try {
+  process.loadEnvFile(".env");
+} catch {
+  // No .env: DATABASE_URL comes from the environment.
+}
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: { path: "prisma/migrations" },
+  datasource: { url: process.env["DATABASE_URL"] ?? "" },
+});
+`;
+}
+/** `src/integrations/database.ts`. */
+export function renderDatabaseIntegration() {
+    return `import { PrismaPg } from "@prisma/adapter-pg";
+import {
+  createDatabaseClient,
+  type DatabaseClient,
+} from "@zudojs/database";
+import { ConfigurationError } from "@zudojs/errors";
+
+import { PrismaClient } from "../generated/prisma/client.js";
+import type { Integration } from "./integration.js";
+
+let client: PrismaClient | undefined;
+let database: DatabaseClient | undefined;
+
+/** The connected Prisma client. Throws before the runtime has started. */
+export function prisma(): PrismaClient {
+  if (client === undefined) {
+    throw new Error("The database is not connected: start the runtime first.");
+  }
+  return client;
+}
+
+export const databaseIntegration: Integration = {
+  name: "database",
+
+  async start({ config }) {
+    if (config.database.url === "") {
+      throw new ConfigurationError(
+        "DATABASE_URL is not set. Copy .env.example to .env, or set it in the environment.",
+      );
+    }
+    const next = new PrismaClient({
+      adapter: new PrismaPg({ connectionString: config.database.url }),
+    });
+    const wrapper = createDatabaseClient({ prisma: next });
+    await wrapper.connect();
+    client = next;
+    database = wrapper;
+  },
+
+  async stop() {
+    const current = database;
+    database = undefined;
+    client = undefined;
+    await current?.disconnect();
+  },
+
+  async health() {
+    if (database === undefined) return false;
+    return database.ping().then(() => true, () => false);
+  },
+};
+`;
+}
+//# sourceMappingURL=database.files.js.map

package/dist/src/recipes/catalog/database/database.recipe.d.ts

@@ -0,0 +1,9 @@
+/**
+ * zudojs-cli — `zudojs add database` (alias `postgres`): PostgreSQL through
+ * Prisma 7 and @zudojs/database. Writes the schema, `prisma.config.ts`,
+ * the client integration and the `db:*` scripts; `generate resource` then
+ * writes Prisma-backed repositories and models.
+ */
+import type { AppRecipe } from "../../recipe.type.js";
+export declare const databaseRecipe: AppRecipe;
+//# sourceMappingURL=database.recipe.d.ts.map

package/dist/src/recipes/catalog/database/database.recipe.js

@@ -0,0 +1,50 @@
+/**
+ * zudojs-cli — `zudojs add database` (alias `postgres`): PostgreSQL through
+ * Prisma 7 and @zudojs/database. Writes the schema, `prisma.config.ts`,
+ * the client integration and the `db:*` scripts; `generate resource` then
+ * writes Prisma-backed repositories and models.
+ */
+import { CLIValidationError } from "../../../errors/index.js";
+import { zudojsDependencies } from "../../../constants/index.js";
+import { DEPENDENCY_VERSION_RANGES } from "../../../resolvers/dependency/dependencyVersions.constant.js";
+import { DATABASE_CONFIG_SECTION } from "../../../templates/backendApp/index.js";
+import { renderDatabaseIntegration, renderPrismaConfig, renderPrismaSchema, } from "./database.files.js";
+export const databaseRecipe = {
+    scope: "app",
+    feature: "database",
+    summary: "PostgreSQL via Prisma 7 (prisma/schema.prisma, src/integrations/database.ts, db:* scripts)",
+    validate: (context) => {
+        if (context.database !== "postgresql") {
+            throw new CLIValidationError(`The database recipe supports PostgreSQL only (@zudojs/database is a PostgreSQL layer); this project records "${context.database}". Change "database.provider" in .zudojs/manifest.json to "postgresql" to use it.`);
+        }
+    },
+    dependencies: {
+        ...zudojsDependencies(["@zudojs/database"]),
+        "@prisma/client": DEPENDENCY_VERSION_RANGES["@prisma/client"],
+        "@prisma/adapter-pg": DEPENDENCY_VERSION_RANGES["@prisma/adapter-pg"],
+    },
+    devDependencies: { prisma: DEPENDENCY_VERSION_RANGES.prisma },
+    scripts: {
+        postinstall: "prisma generate",
+        "db:generate": "prisma generate",
+        "db:migrate": "prisma migrate dev",
+        "db:deploy": "prisma migrate deploy",
+    },
+    replaceScripts: { build: { from: "tsc", to: "prisma generate && tsc" } },
+    env: (context) => [
+        { name: "DATABASE_URL", value: `postgresql://postgres:change-me@localhost:5432/${context.projectSlug}` },
+    ],
+    configSection: DATABASE_CONFIG_SECTION,
+    integration: { file: "database.ts", exportName: "databaseIntegration", source: renderDatabaseIntegration },
+    files: () => ({
+        "prisma/schema.prisma": renderPrismaSchema(),
+        "prisma.config.ts": renderPrismaConfig(),
+    }),
+    gitignore: (context) => [`${context.appRoot === "" ? "" : `${context.appRoot}/`}src/generated/`],
+    allowBuilds: ["prisma", "@prisma/engines", "@prisma/client"],
+    nextSteps: () => [
+        "Set DATABASE_URL in .env, then run the db:migrate script after adding models.",
+        "Resources generated from now on use Prisma; existing ones keep their in-memory repository until you swap it in src/container.ts.",
+    ],
+};
+//# sourceMappingURL=database.recipe.js.map

package/dist/src/recipes/catalog/database/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — The Prisma/PostgreSQL database recipe.
+ */
+export { databaseRecipe } from "./database.recipe.js";
+export * from "./database.files.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/recipes/catalog/database/index.js

@@ -0,0 +1,6 @@
+/**
+ * zudojs-cli — The Prisma/PostgreSQL database recipe.
+ */
+export { databaseRecipe } from "./database.recipe.js";
+export * from "./database.files.js";
+//# sourceMappingURL=index.js.map

package/dist/src/recipes/catalog/email.recipe.d.ts

@@ -0,0 +1,9 @@
+/**
+ * zudojs-cli — `zudojs add email`: an `EmailTransport` abstraction with two
+ * implementations: `console` (development default: logs the recipient and
+ * subject, never the body) and `smtp` (nodemailer). SMTP credentials come
+ * from the environment only; nothing secret is written to source.
+ */
+import type { AppRecipe } from "../recipe.type.js";
+export declare const emailRecipe: AppRecipe;
+//# sourceMappingURL=email.recipe.d.ts.map

package/dist/src/recipes/catalog/email.recipe.js

@@ -0,0 +1,122 @@
+/**
+ * zudojs-cli — `zudojs add email`: an `EmailTransport` abstraction with two
+ * implementations: `console` (development default: logs the recipient and
+ * subject, never the body) and `smtp` (nodemailer). SMTP credentials come
+ * from the environment only; nothing secret is written to source.
+ */
+import { DEPENDENCY_VERSION_RANGES } from "../../resolvers/dependency/dependencyVersions.constant.js";
+const source = () => `import { createTransport } from "nodemailer";
+
+import type { AppConfig } from "../configs/index.js";
+import type { Integration, IntegrationContext } from "./integration.js";
+
+/** A message to send. */
+export interface EmailMessage {
+  readonly to: string | readonly string[];
+  readonly subject: string;
+  readonly text: string;
+  readonly html?: string;
+}
+
+/** Sends email; swap implementations through EMAIL_TRANSPORT. */
+export interface EmailTransport {
+  send(message: EmailMessage): Promise<void>;
+  verify(): Promise<boolean>;
+  close(): void;
+}
+
+function consoleTransport(logger: IntegrationContext["logger"]): EmailTransport {
+  return {
+    async send(message) {
+      logger.info("Email (console transport, not sent)", {
+        to: message.to,
+        subject: message.subject,
+      });
+    },
+    async verify() {
+      return true;
+    },
+    close() {},
+  };
+}
+
+function smtpTransport(settings: AppConfig["email"]): EmailTransport {
+  const transporter = createTransport({
+    host: settings.smtpHost,
+    port: settings.smtpPort,
+    secure: settings.smtpSecure,
+    ...(settings.smtpUser === ""
+      ? {}
+      : { auth: { user: settings.smtpUser, pass: settings.smtpPassword } }),
+  });
+  return {
+    async send(message) {
+      await transporter.sendMail({
+        from: settings.from,
+        to: typeof message.to === "string" ? message.to : [...message.to],
+        subject: message.subject,
+        text: message.text,
+        ...(message.html === undefined ? {} : { html: message.html }),
+      });
+    },
+    async verify() {
+      return transporter.verify().then(() => true, () => false);
+    },
+    close() {
+      transporter.close();
+    },
+  };
+}
+
+let transport: EmailTransport | undefined;
+
+/** The configured transport. Throws before the runtime has started. */
+export function email(): EmailTransport {
+  if (transport === undefined) {
+    throw new Error("Email is not configured: start the runtime first.");
+  }
+  return transport;
+}
+
+export const emailIntegration: Integration = {
+  name: "email",
+
+  async start({ config, logger }) {
+    const kind = config.email.transport;
+    if (kind !== "console" && kind !== "smtp") {
+      throw new Error(\`EMAIL_TRANSPORT must be "console" or "smtp", got "\${kind}".\`);
+    }
+    transport = kind === "smtp" ? smtpTransport(config.email) : consoleTransport(logger);
+  },
+
+  async stop() {
+    transport?.close();
+    transport = undefined;
+  },
+
+  async health() {
+    return transport === undefined ? false : transport.verify();
+  },
+};
+`;
+export const emailRecipe = {
+    scope: "app",
+    feature: "email",
+    summary: "Email transport (src/integrations/email.ts): console in development, SMTP via nodemailer",
+    dependencies: { nodemailer: DEPENDENCY_VERSION_RANGES.nodemailer },
+    env: () => [
+        { name: "EMAIL_TRANSPORT", value: "console", comment: "console (logs only) or smtp" },
+        { name: "EMAIL_FROM", value: "no-reply@localhost" },
+        { name: "SMTP_HOST", value: "localhost" },
+        { name: "SMTP_PORT", value: "1025" },
+        { name: "SMTP_SECURE", value: "false" },
+        { name: "SMTP_USER", value: "" },
+        { name: "SMTP_PASSWORD", value: "", comment: "Issued by your SMTP provider; unused by the console transport and Mailpit" },
+    ],
+    configSection: `email: Object.freeze({ transport: text(config, "email_transport", "console"), from: text(config, "email_from", "no-reply@localhost"), smtpHost: text(config, "smtp_host", "localhost"), smtpPort: int(config, "smtp_port", 1025), smtpSecure: text(config, "smtp_secure", "false") === "true", smtpUser: text(config, "smtp_user", ""), smtpPassword: text(config, "smtp_password", "") }),`,
+    integration: { file: "email.ts", exportName: "emailIntegration", source },
+    nextSteps: () => [
+        `Send with: import { email } from "./integrations/email.js"; await email().send({ to, subject, text });`,
+    ],
+};
+//# sourceMappingURL=email.recipe.js.map

package/dist/src/recipes/catalog/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * zudojs-cli — App recipes, one per feature.
+ */
+export { emailRecipe } from "./email.recipe.js";
+export { openapiRecipe } from "./openapi.recipe.js";
+export { redisRecipe } from "./redis.recipe.js";
+export { storageRecipe } from "./storage.recipe.js";
+export { websocketsRecipe } from "./websockets.recipe.js";
+export { databaseRecipe } from "./database/index.js";
+export * from "./platform/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/recipes/catalog/index.js

@@ -0,0 +1,11 @@
+/**
+ * zudojs-cli — App recipes, one per feature.
+ */
+export { emailRecipe } from "./email.recipe.js";
+export { openapiRecipe } from "./openapi.recipe.js";
+export { redisRecipe } from "./redis.recipe.js";
+export { storageRecipe } from "./storage.recipe.js";
+export { websocketsRecipe } from "./websockets.recipe.js";
+export { databaseRecipe } from "./database/index.js";
+export * from "./platform/index.js";
+//# sourceMappingURL=index.js.map

package/dist/src/recipes/catalog/openapi.recipe.d.ts

@@ -0,0 +1,8 @@
+/**
+ * zudojs-cli — `zudojs add openapi`: serves the OpenAPI document generated
+ * from the router at /openapi.json and a documentation page at /docs, by
+ * adding `mountOpenAPI` to `src/server.ts`.
+ */
+import type { AppRecipe } from "../recipe.type.js";
+export declare const openapiRecipe: AppRecipe;
+//# sourceMappingURL=openapi.recipe.d.ts.map

package/dist/src/recipes/catalog/openapi.recipe.js

@@ -0,0 +1,25 @@
+/**
+ * zudojs-cli — `zudojs add openapi`: serves the OpenAPI document generated
+ * from the router at /openapi.json and a documentation page at /docs, by
+ * adding `mountOpenAPI` to `src/server.ts`.
+ */
+import { zudojsDependencies } from "../../constants/index.js";
+import { openApiServerLines } from "../../templates/shared/server.template.js";
+import { MARKERS } from "../../wiring/index.js";
+export const openapiRecipe = {
+    scope: "app",
+    feature: "openapi",
+    summary: "OpenAPI document at /openapi.json and a docs page at /docs",
+    dependencies: zudojsDependencies(["@zudojs/openapi"]),
+    serverLines: (context) => {
+        const lines = openApiServerLines(context.projectSlug);
+        return [
+            { marker: MARKERS.serverImports, line: lines.importLine },
+            { marker: MARKERS.serverMounts, line: lines.mountLine },
+        ];
+    },
+    nextSteps: () => [
+        "Describe routes with the `openapi` route option; hide one with `openapi: false`.",
+    ],
+};
+//# sourceMappingURL=openapi.recipe.js.map

package/dist/src/recipes/catalog/platform/cache.recipe.d.ts

@@ -0,0 +1,7 @@
+/**
+ * zudojs-cli — `zudojs add cache`: an in-memory cache (@zudojs/cache) with
+ * a bounded entry count and a default TTL from the environment.
+ */
+import type { AppRecipe } from "../../recipe.type.js";
+export declare const cacheRecipe: AppRecipe;
+//# sourceMappingURL=cache.recipe.d.ts.map