@aventara/cli 0.0.0-stage → 0.1.0-pilot.1

package/dist/run/new.orchestrator.js

@@ -0,0 +1,88 @@
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { detectPackageManager } from "../project/package-manager.detector.js";
+import { ProjectRefusedError } from "../project/project.inspector.js";
+import { resolveAnswers } from "../wizard/answer.resolver.js";
+import { NEW_QUESTIONS } from "../wizard/wizard.questions.js";
+import { InstallFailedError, runInit, } from "./init.orchestrator.js";
+/**
+ * `aventara new <name>` (R2, D1): the pinned `nest new`, then **exactly**
+ * `aventara init`'s pipeline over the fresh project, with the wizard's answers
+ * carried in — so every `new` run exercises the anchored edit, the merges and
+ * the templates `init` uses.
+ *
+ * Nest authors its own scaffold (D1): the CLI never writes Nest's files. Its
+ * output is pinned by digest (B24), so a `@nestjs/cli` that writes something
+ * else stops the run before anything of Aventara's is written over it.
+ */
+/** D1: the `nest new` this CLI was measured against (B1, B24). */
+export const NEST_CLI = "@nestjs/cli@12.0.8";
+/** B24: `src/app.module.ts` as `@nestjs/cli` 12.0.8 writes it — the anchored edit's file. */
+export const NEST_APP_MODULE_SHA256 = "fe98c4cd2552342272494652287c02e4ef58db3072fcb18513ea831c60f85778";
+/** The command that runs a package from the registry once, per package manager (B11, B21). */
+function oneOff(packageManager) {
+    return packageManager === "pnpm" ? ["pnpm", ["dlx"]] : ["npx", ["-y"]];
+}
+export async function runNew(command, io) {
+    const answers = await resolveAnswers(NEW_QUESTIONS, {
+        given: command.given,
+        yes: command.yes,
+        prompter: io.prompter,
+        context: {
+            catalog: io.catalog,
+            detectedPackageManager: detectPackageManager({
+                userAgent: io.env.npm_config_user_agent,
+            }),
+        },
+    });
+    const { name, orm, db, packageManager } = answers;
+    if (name === undefined ||
+        orm === undefined ||
+        db === undefined ||
+        packageManager === undefined) {
+        throw new Error("the new questions settled without every answer");
+    }
+    const directory = path.join(io.cwd, name);
+    if (existsSync(directory) && readdirSync(directory).length > 0) {
+        throw new ProjectRefusedError(`aventara new creates ${directory}, which already exists and is not empty; choose another name, or run aventara init inside an existing project`);
+    }
+    // stdout piped by the runner (B25): on a terminal, nest new asks the module
+    // system, with no flag to answer it; piped, it asks nothing and writes ESM.
+    const [runner, prefix] = oneOff(packageManager);
+    const args = [
+        ...prefix,
+        NEST_CLI,
+        "new",
+        name,
+        "--package-manager",
+        packageManager,
+        "--skip-install",
+        "--no-observe",
+        ...(command.skipGit ? ["--skip-git"] : []),
+    ];
+    io.stdout(`aventara: running ${runner} ${args.join(" ")}…\n`);
+    const created = await io.runner(runner, args, { cwd: io.cwd });
+    if (created.code !== 0) {
+        throw new InstallFailedError(`\`${runner} ${args.join(" ")}\` exited with code ${created.code}, and nothing of Aventara's was written; fix what it reports and run aventara new again:\n${created.stderr.trimEnd()}`);
+    }
+    const appModule = path.join(directory, "src", "app.module.ts");
+    const digest = existsSync(appModule)
+        ? createHash("sha256").update(readFileSync(appModule)).digest("hex")
+        : "(absent)";
+    if (digest !== NEST_APP_MODULE_SHA256) {
+        throw new InstallFailedError(`nest new's output changed: ${appModule} is not what ${NEST_CLI} writes (sha256 ${digest}), so nothing of Aventara's was written over it; run aventara init inside ${directory} to add Aventara to it`);
+    }
+    return runInit({
+        command: "init",
+        given: {
+            orm: `${orm.orm.family}@${orm.orm.major}`,
+            db,
+            packageManager,
+        },
+        skipInstall: command.skipInstall,
+        skipGit: false,
+        // A fresh project: there is nothing of the developer's to confirm over.
+        yes: true,
+    }, { ...io, directory, firstSteps: [`Enter the project: cd ${name}`] });
+}

package/dist/templates/prisma7/prisma7.templates.d.ts

@@ -0,0 +1,34 @@
+import type { PackageManifest } from "../../apply/manifest.merger.js";
+import type { ClientShape, ExportReference } from "../../project/service.detector.js";
+import { type OrmProjectFacts, type OrmScaffold, type ReuseInput, type ScaffoldInput } from "../template.registry.js";
+declare function scaffold(input: ScaffoldInput): OrmScaffold;
+declare function reuse(input: ReuseInput): OrmScaffold;
+declare function readProject(directory: string, manifest: PackageManifest): OrmProjectFacts;
+declare function clientShape(facts: OrmProjectFacts): ClientShape;
+export declare const PRISMA7_TEMPLATES: {
+    readonly providers: {
+        readonly sqlite: {
+            readonly driverClass: "PrismaBetterSqlite3";
+            readonly driverOptions: "{ url }";
+            readonly databaseUrl: "file:./dev.db";
+            readonly gitignore: readonly ["/dev.db*"];
+            readonly nativeBuilds: readonly ["@prisma/engines", "better-sqlite3", "prisma"];
+        };
+        readonly postgresql: {
+            readonly driverClass: "PrismaPg";
+            readonly driverOptions: "{ connectionString: url }";
+            readonly databaseUrl: "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public";
+            readonly gitignore: readonly [];
+            readonly nativeBuilds: readonly ["@prisma/engines", "prisma"];
+        };
+    };
+    readonly scaffold: typeof scaffold;
+    readonly readProject: typeof readProject;
+    readonly clientShape: typeof clientShape;
+    readonly newService: {
+        readonly service: ExportReference;
+        readonly module: ExportReference;
+    };
+    readonly reuse: typeof reuse;
+};
+export {};

package/dist/templates/prisma7/prisma7.templates.js

@@ -0,0 +1,397 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { lowestVersionOf } from "../../catalog/range.reader.js";
+import { SCAFFOLD_ENTRYPOINT, } from "../template.registry.js";
+/**
+ * The `prisma7` entry's templates (D7): Prisma 7 knowledge as text the CLI
+ * writes and reads, keyed by the providers `@aventara/prisma7-adapter`
+ * declares. Every value that is an adapter fact — the ORM package, the driver
+ * per provider, the generator, the generate bin, the version floor — is read
+ * from the catalog entry handed in, not restated here.
+ *
+ * The texts follow the Nest scaffold's formatting (prettier, `singleQuote`,
+ * `trailingComma: "all"`, B1), so the project's own `format` script leaves them
+ * as they are.
+ */
+/** The generated client goes under `src`, where `nest build` compiles it (B6). */
+const CLIENT_OUTPUT = "src/generated/prisma";
+const SCHEMA = "prisma/schema.prisma";
+/** B5: the Prisma CLI loads either name, and `prisma7.config.ts` wins when both exist. */
+const CONFIG_FILES = ["prisma7.config.ts", "prisma.config.ts"];
+const DRIVER_PREFIX = "@prisma/adapter-";
+const NEW_SERVICE = {
+    file: "src/prisma.service.ts",
+    exportName: "PrismaService",
+};
+const NEW_MODULE = {
+    file: "src/prisma.service.ts",
+    exportName: "PrismaModule",
+};
+const PROVIDERS = {
+    sqlite: {
+        driverClass: "PrismaBetterSqlite3",
+        driverOptions: "{ url }",
+        databaseUrl: "file:./dev.db",
+        gitignore: ["/dev.db*"],
+        // B9: pnpm 12 refuses these install scripts until they are allowed.
+        nativeBuilds: ["@prisma/engines", "better-sqlite3", "prisma"],
+    },
+    postgresql: {
+        driverClass: "PrismaPg",
+        driverOptions: "{ connectionString: url }",
+        // `prisma init`'s own placeholder (B5); printed in the next steps, never asked (Q16-8).
+        databaseUrl: "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public",
+        gitignore: [],
+        nativeBuilds: ["@prisma/engines", "prisma"],
+    },
+};
+/** A relative import specifier from `from` (a project file) to `to` (a project path, no extension). */
+function specifier(from, to, js) {
+    const relative = path.posix.relative(path.posix.dirname(from), to);
+    return `${relative.startsWith(".") ? relative : `./${relative}`}${js}`;
+}
+function schema(input) {
+    return [
+        "generator client {",
+        `  provider = "${input.entry.generators[0]}"`,
+        `  output   = "../${CLIENT_OUTPUT}"`,
+        ...(input.moduleKind === "cjs" ? ['  moduleFormat = "cjs"'] : []),
+        "}",
+        "",
+        "datasource db {",
+        `  provider = "${input.provider}"`,
+        "}",
+        "",
+        // R12: Prisma's `--with-model` starter (B5).
+        "model User {",
+        "  id    Int     @id @default(autoincrement())",
+        "  email String  @unique",
+        "  name  String?",
+        "}",
+        "",
+    ].join("\n");
+}
+/** `prisma.config.ts` (Q16-19). Prisma does not load `.env` itself (B5). */
+function prismaConfig() {
+    return [
+        "import { existsSync } from 'node:fs';",
+        "import { defineConfig } from 'prisma/config';",
+        "",
+        "// Prisma reads DATABASE_URL from the environment and does not load .env itself.",
+        "if (existsSync('.env')) {",
+        "  process.loadEnvFile('.env');",
+        "}",
+        "",
+        "export default defineConfig({",
+        `  schema: '${SCHEMA}',`,
+        "  migrations: {",
+        "    path: 'prisma/migrations',",
+        "  },",
+        "  datasource: {",
+        "    url: process.env.DATABASE_URL,",
+        "  },",
+        "});",
+        "",
+    ].join("\n");
+}
+/** The developer-owned service (P2: `extends PrismaClient`, so `client: prisma`). */
+function prismaService(input) {
+    const provider = PROVIDERS[input.provider];
+    const driver = input.entry.drivers[input.provider];
+    return [
+        "import { Injectable, Module, type OnModuleDestroy } from '@nestjs/common';",
+        `import { ${provider.driverClass} } from '${driver}';`,
+        `import { PrismaClient } from '${specifier(NEW_SERVICE.file, `${input.clientOutput}/client`, input.js)}';`,
+        "",
+        "@Injectable()",
+        "export class PrismaService extends PrismaClient implements OnModuleDestroy {",
+        "  constructor() {",
+        "    const url = process.env.DATABASE_URL;",
+        "    if (!url) {",
+        "      // Thrown while Nest builds the application, before it listens.",
+        "      throw new Error(",
+        "        'DATABASE_URL is not set: put it in .env (the start scripts load it) or in the environment.',",
+        "      );",
+        "    }",
+        `    super({ adapter: new ${provider.driverClass}(${provider.driverOptions}) });`,
+        "  }",
+        "",
+        "  async onModuleDestroy(): Promise<void> {",
+        "    await this.$disconnect();",
+        "  }",
+        "}",
+        "",
+        "@Module({ providers: [PrismaService], exports: [PrismaService] })",
+        "export class PrismaModule {}",
+        "",
+    ].join("\n");
+}
+/** `src/aventara.config.ts` (R8, Q16-17): the framework's configuration. */
+function aventaraConfig(input) {
+    const file = "src/aventara.config.ts";
+    const service = input.service.exportName;
+    return [
+        `import { createPrismaAdapter } from '${input.entry.adapterPackage}';`,
+        `import { discovery } from '${specifier(file, input.artifact.replace(/\.ts$/, ""), input.js)}';`,
+        `import type { ${service} } from '${specifier(file, input.service.file.replace(/\.ts$/, ""), input.js)}';`,
+        "",
+        "/**",
+        " * Aventara's configuration: the entrypoint, and the restrictions and",
+        " * pipelines you add. AventaraModule (app.module.ts) builds the framework from",
+        " * it; `discovery` is regenerated by the aventara:prepare script.",
+        " */",
+        `export async function aventaraConfig(prisma: ${service}) {`,
+        "  return {",
+        `    entrypoint: '${SCAFFOLD_ENTRYPOINT}',`,
+        "    adapter: await createPrismaAdapter({",
+        input.service.clientMember === undefined
+            ? "      client: prisma,"
+            : `      client: prisma.${input.service.clientMember},`,
+        "      discovery,",
+        `      provider: '${input.provider}',`,
+        `      driver: '${input.entry.drivers[input.provider]}',`,
+        "    }),",
+        "  } as const;",
+        "}",
+        "",
+    ].join("\n");
+}
+function prepare(input) {
+    return [
+        input.entry.bin,
+        `--schema ${input.schema}`,
+        `--client ${input.clientOutput}`,
+        `--provider ${input.provider}`,
+        `--driver ${input.entry.drivers[input.provider]}`,
+        `--out ${input.artifact}`,
+    ].join(" ");
+}
+function appModule(service, module, js) {
+    const from = "src/app.module.ts";
+    const sameFile = service.file === module.file;
+    return {
+        imports: [
+            `import { aventaraConfig } from '${specifier(from, "src/aventara.config", js)}';`,
+            ...(sameFile
+                ? [
+                    `import { ${module.exportName}, ${service.exportName} } from '${specifier(from, service.file.replace(/\.ts$/, ""), js)}';`,
+                ]
+                : [
+                    `import { ${module.exportName} } from '${specifier(from, module.file.replace(/\.ts$/, ""), js)}';`,
+                    `import { ${service.exportName} } from '${specifier(from, service.file.replace(/\.ts$/, ""), js)}';`,
+                ]),
+        ],
+        entries: [
+            `${module.exportName},`,
+            [
+                "AventaraModule.forRootAsync({",
+                `  imports: [${module.exportName}],`,
+                `  inject: [${service.exportName}],`,
+                `  useFactory: async (prisma: ${service.exportName}) => ({`,
+                "    config: await aventaraConfig(prisma),",
+                "  }),",
+                "}),",
+            ].join("\n"),
+        ],
+    };
+}
+function scaffold(input) {
+    const js = input.moduleKind === "esm" ? ".js" : "";
+    const floor = lowestVersionOf(input.entry.range);
+    const provider = PROVIDERS[input.provider];
+    const driver = input.entry.drivers[input.provider];
+    const run = input.packageManager === "pnpm" ? "pnpm exec" : "npx";
+    const artifact = "src/generated/aventara/discovery.artifact.ts";
+    return {
+        files: [
+            { path: SCHEMA, content: schema(input) },
+            { path: "prisma.config.ts", content: prismaConfig() },
+            {
+                path: NEW_SERVICE.file,
+                content: prismaService({ ...input, clientOutput: CLIENT_OUTPUT, js }),
+            },
+            {
+                path: "src/aventara.config.ts",
+                content: aventaraConfig({
+                    ...input,
+                    service: NEW_SERVICE,
+                    artifact,
+                    js,
+                }),
+            },
+        ],
+        env: { DATABASE_URL: provider.databaseUrl },
+        gitignore: ["/src/generated/", ...provider.gitignore],
+        // D1, D9: exactly the version floor the adapter declares; never bare `prisma`.
+        dependencies: { [input.entry.orm.package]: floor, [driver]: floor },
+        devDependencies: { prisma: floor },
+        prepare: prepare({
+            ...input,
+            schema: SCHEMA,
+            clientOutput: CLIENT_OUTPUT,
+            artifact,
+        }),
+        appModule: appModule(NEW_SERVICE, NEW_MODULE, js),
+        nativeBuilds: provider.nativeBuilds,
+        nextSteps: [
+            ...(input.provider === "postgresql"
+                ? ["Set DATABASE_URL in .env to your PostgreSQL database."]
+                : []),
+            `Create the database tables: ${run} prisma db push`,
+        ],
+    };
+}
+function reuse(input) {
+    const js = input.moduleKind === "esm" ? ".js" : "";
+    const { facts } = input;
+    return {
+        files: [
+            ...(input.writeService
+                ? [
+                    {
+                        path: NEW_SERVICE.file,
+                        content: prismaService({
+                            entry: input.entry,
+                            provider: facts.provider,
+                            clientOutput: facts.clientOutput,
+                            js,
+                        }),
+                    },
+                ]
+                : []),
+            {
+                path: "src/aventara.config.ts",
+                content: aventaraConfig({
+                    entry: input.entry,
+                    provider: facts.provider,
+                    service: input.service,
+                    artifact: input.artifact,
+                    js,
+                }),
+            },
+        ],
+        // R6: the developer's Prisma files, `.env` key and versions are theirs.
+        env: {},
+        gitignore: [`/${path.posix.dirname(input.artifact)}/`],
+        dependencies: {},
+        devDependencies: {},
+        prepare: prepare({
+            entry: input.entry,
+            schema: facts.schema,
+            clientOutput: facts.clientOutput,
+            provider: facts.provider,
+            artifact: input.artifact,
+        }),
+        appModule: appModule(input.service, input.module, js),
+        nativeBuilds: [],
+        nextSteps: [],
+    };
+}
+/* ------------------------------------------------------------------ *
+ * Reading an existing Prisma 7 setup (R6)                              *
+ * ------------------------------------------------------------------ */
+function schemaLocation(directory, manifest) {
+    for (const config of CONFIG_FILES) {
+        const file = path.join(directory, config);
+        if (existsSync(file)) {
+            const declared = /\bschema\s*:\s*['"]([^'"]+)['"]/.exec(readFileSync(file, "utf8"))?.[1];
+            if (declared !== undefined) {
+                return path.posix.normalize(declared);
+            }
+        }
+    }
+    const prisma = manifest.prisma;
+    return typeof prisma?.schema === "string"
+        ? path.posix.normalize(prisma.schema)
+        : SCHEMA;
+}
+/** The `.prisma` files of a schema path: the file, or every file in a schema folder. */
+function schemaFiles(directory, schemaPath) {
+    const full = path.join(directory, schemaPath);
+    if (!existsSync(full)) {
+        return [];
+    }
+    if (!statSync(full).isDirectory()) {
+        return [schemaPath];
+    }
+    return readdirSync(full, { recursive: true, withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".prisma"))
+        .map((entry) => path
+        .relative(directory, path.join(entry.parentPath, entry.name))
+        .split(path.sep)
+        .join("/"))
+        .sort();
+}
+function blocks(text, kind) {
+    return [
+        ...text.matchAll(new RegExp(`^\\s*${kind}\\s+\\w+\\s*\\{([^}]*)\\}`, "gm")),
+    ].map((match) => match[1]);
+}
+function setting(block, name) {
+    return new RegExp(`^\\s*${name}\\s*=\\s*"([^"]*)"`, "m").exec(block)?.[1];
+}
+function readProject(directory, manifest) {
+    const schemaPath = schemaLocation(directory, manifest);
+    let provider;
+    let generator;
+    let clientOutput;
+    for (const file of schemaFiles(directory, schemaPath)) {
+        const text = readFileSync(path.join(directory, file), "utf8").replace(/\/\/.*$/gm, "");
+        provider ??= blocks(text, "datasource")
+            .map((block) => setting(block, "provider"))
+            .find((value) => value !== undefined);
+        for (const block of blocks(text, "generator")) {
+            const declared = setting(block, "provider");
+            const output = setting(block, "output");
+            // The client generator, not a second generator (a zod or docs one) beside it.
+            if (generator === undefined || /^prisma-client/.test(declared ?? "")) {
+                generator = declared;
+                clientOutput =
+                    output === undefined
+                        ? undefined
+                        : path.posix.normalize(path.posix.join(path.posix.dirname(file), output));
+            }
+        }
+    }
+    const dependencies = [
+        ...Object.keys(manifest.dependencies ?? {}),
+        ...Object.keys(manifest.devDependencies ?? {}),
+    ];
+    return {
+        schema: schemaPath,
+        provider,
+        generator,
+        clientOutput,
+        drivers: dependencies.filter((name) => name.startsWith(DRIVER_PREFIX)),
+    };
+}
+function clientShape(facts) {
+    return {
+        clientClass: "PrismaClient",
+        importsClient: (imported, file) => {
+            if (!imported.startsWith(".")) {
+                return imported === "@prisma/client";
+            }
+            if (facts.clientOutput === undefined) {
+                return false;
+            }
+            const resolved = path.posix
+                .join(path.posix.dirname(file), imported)
+                .replace(/\.(js|ts)$/, "");
+            return (resolved === facts.clientOutput ||
+                resolved === `${facts.clientOutput}/client` ||
+                resolved === `${facts.clientOutput}/index`);
+        },
+        skip: facts.clientOutput === undefined
+            ? ["src/generated"]
+            : ["src/generated", facts.clientOutput],
+    };
+}
+export const PRISMA7_TEMPLATES = {
+    providers: PROVIDERS,
+    scaffold,
+    readProject,
+    clientShape,
+    newService: { service: NEW_SERVICE, module: NEW_MODULE },
+    reuse,
+};

package/dist/templates/template.registry.d.ts

@@ -0,0 +1,156 @@
+import type { PackageManifest } from "../apply/manifest.merger.js";
+import type { CatalogEntry, EntryId, ProviderOf } from "../catalog/catalog-entry.interface.js";
+import type { ClientShape, ExportReference } from "../project/service.detector.js";
+import type { PackageManager } from "../wizard/wizard.questions.js";
+/**
+ * D7 — what the CLI writes for an ORM lives here as text, keyed by catalog id;
+ * the adapter itself runs only through its bin.
+ *
+ * The registry is **total** in both directions, and both are checked before a
+ * project is ever scaffolded:
+ * - at compile time, over the generated catalog's literal type: an entry with
+ *   no template set, or a template set missing a provider its adapter declares,
+ *   does not type-check;
+ * - at build time, by the catalog generator: a templates directory with no
+ *   adapter, or an adapter with no templates directory, fails the build.
+ */
+/** What changes with the database provider an entry offers. */
+export type ProviderTemplate = {
+    /** The driver adapter's class, constructed in the written ORM service. */
+    readonly driverClass: string;
+    /** The driver class's constructor argument, given the connection string as `url`. */
+    readonly driverOptions: string;
+    /** The `DATABASE_URL` line's value; a placeholder where it cannot be known (Q16-8). */
+    readonly databaseUrl: string;
+    /** `.gitignore` lines this provider's files need (a SQLite database file). */
+    readonly gitignore: readonly string[];
+    /** Packages whose install scripts pnpm must be allowed to run (B9). */
+    readonly nativeBuilds: readonly string[];
+};
+export type ModuleKind = "esm" | "cjs";
+/**
+ * The entrypoint every scaffold mounts the protocol at: written into
+ * `src/aventara.config.ts`, and tested by the e2e spec (pilot.1).
+ */
+export declare const SCAFFOLD_ENTRYPOINT = "/api";
+/** What a template set is asked to scaffold. */
+export type ScaffoldInput = {
+    readonly entry: CatalogEntry;
+    /** One of `entry.providers`. */
+    readonly provider: string;
+    readonly moduleKind: ModuleKind;
+    readonly packageManager: PackageManager;
+};
+/**
+ * What an ORM's templates contribute to a project. Everything here is the
+ * ORM's; what is Nest's (the start scripts, the anchored `app.module.ts` edit,
+ * `AventaraModule`'s import) and what is Aventara's (its packages, the
+ * `aventara:prepare` and `postinstall` script names) is the planner's.
+ */
+export type OrmScaffold = {
+    /** New, developer-owned files (§4.3). */
+    readonly files: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    /** `.env` entries. */
+    readonly env: Readonly<Record<string, string>>;
+    readonly gitignore: readonly string[];
+    readonly dependencies: Readonly<Record<string, string>>;
+    readonly devDependencies: Readonly<Record<string, string>>;
+    /** The command `aventara:prepare` runs (D7: the adapter only through its bin). */
+    readonly prepare: string;
+    /** What the anchored `app.module.ts` edit adds: import lines, and `imports:` entries. */
+    readonly appModule: {
+        readonly imports: readonly string[];
+        readonly entries: readonly string[];
+    };
+    readonly nativeBuilds: readonly string[];
+    /** The ORM's next steps, after the install and before the server starts (R11). */
+    readonly nextSteps: readonly string[];
+};
+/**
+ * What a project's existing ORM setup states, read by the entry's templates
+ * (R6) — the ORM's own file layout is template knowledge (D7); judging it
+ * against the catalog is the matcher's (`catalog.matcher.ts`).
+ */
+export type OrmProjectFacts = {
+    /** The schema the generate step reads, relative to the project root. */
+    readonly schema: string;
+    readonly provider: string | undefined;
+    readonly generator: string | undefined;
+    /** The generated client's directory, relative to the project root. */
+    readonly clientOutput: string | undefined;
+    /** The driver-adapter packages the project depends on. */
+    readonly drivers: readonly string[];
+};
+/** Reusing a project's ORM setup (R6): its schema, its output, its service. */
+export type ReuseInput = {
+    readonly entry: CatalogEntry;
+    readonly facts: OrmProjectFacts & {
+        readonly provider: string;
+        readonly clientOutput: string;
+    };
+    readonly moduleKind: ModuleKind;
+    readonly packageManager: PackageManager;
+    /** The developer's service, or the template's new one when it is to be written. */
+    readonly service: ExportReference & {
+        readonly clientMember?: string;
+    };
+    readonly module: ExportReference;
+    /** Whether `service` and `module` are the template's new file, to be written. */
+    readonly writeService: boolean;
+    /** Where the discovery artifact goes, relative to the project root. */
+    readonly artifact: string;
+};
+export type TemplateSet<I extends EntryId> = {
+    readonly providers: {
+        readonly [P in ProviderOf<I>]: ProviderTemplate;
+    };
+    /** A project with no ORM: everything §4.3 lists. */
+    readonly scaffold: (input: ScaffoldInput) => OrmScaffold;
+    /** Reads an existing setup's facts; `undefined` when there is none to read. */
+    readonly readProject: (directory: string, manifest: PackageManifest) => OrmProjectFacts;
+    /** How the developer's service is recognised in their source. */
+    readonly clientShape: (facts: OrmProjectFacts) => ClientShape;
+    /** The service init writes when the project has none: its file and names. */
+    readonly newService: {
+        readonly service: ExportReference;
+        readonly module: ExportReference;
+    };
+    /** A project with the ORM already set up: no ORM file written or edited (R6). */
+    readonly reuse: (input: ReuseInput) => OrmScaffold;
+};
+export type TemplateRegistry = {
+    readonly [I in EntryId]: TemplateSet<I>;
+};
+export declare const TEMPLATE_REGISTRY: {
+    readonly prisma7: {
+        readonly providers: {
+            readonly sqlite: {
+                readonly driverClass: "PrismaBetterSqlite3";
+                readonly driverOptions: "{ url }";
+                readonly databaseUrl: "file:./dev.db";
+                readonly gitignore: readonly ["/dev.db*"];
+                readonly nativeBuilds: readonly ["@prisma/engines", "better-sqlite3", "prisma"];
+            };
+            readonly postgresql: {
+                readonly driverClass: "PrismaPg";
+                readonly driverOptions: "{ connectionString: url }";
+                readonly databaseUrl: "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public";
+                readonly gitignore: readonly [];
+                readonly nativeBuilds: readonly ["@prisma/engines", "prisma"];
+            };
+        };
+        readonly scaffold: (input: ScaffoldInput) => OrmScaffold;
+        readonly readProject: (directory: string, manifest: PackageManifest) => OrmProjectFacts;
+        readonly clientShape: (facts: OrmProjectFacts) => ClientShape;
+        readonly newService: {
+            readonly service: ExportReference;
+            readonly module: ExportReference;
+        };
+        readonly reuse: (input: ReuseInput) => OrmScaffold;
+    };
+};
+/** The template set for `entry` — every catalog entry has one (checked at build). */
+export declare function templatesFor(entry: CatalogEntry): TemplateSet<EntryId>;