@aventara/cli 1.0.0-rc.4 → 1.0.0-rc.9

package/dist/templates/prisma7/prisma7-nest.templates.js

@@ -0,0 +1,242 @@
+import path from "node:path";
+import { hostOf } from "../../catalog/host-entry.interface.js";
+import { lowestVersionOf } from "../../catalog/range.reader.js";
+import { EXPOSURE_DOCS } from "../docs.links.js";
+import { SCAFFOLD_API, } from "../template.registry.js";
+import { CLIENT_OUTPUT, discoveryImport, PROVIDERS, prepare, prismaConfig, resourcesTreeBeside, SCHEMA, schema, specifier, } from "./prisma7-orm.templates.js";
+const NEST = hostOf("nest");
+const CONFIG_FILE = `${NEST.layout.config}.ts`;
+const ADAPTER_FILE = `${NEST.layout.adapter}.ts`;
+const NEW_SERVICE = {
+    file: "src/prisma.service.ts",
+    exportName: "PrismaService",
+};
+const NEW_MODULE = {
+    file: "src/prisma.service.ts",
+    exportName: "PrismaModule",
+};
+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");
+}
+function aventaraConfig(js, artifact) {
+    return [
+        "import type { AvDiagnostic } from '@aventara/core';",
+        "import { Logger } from '@nestjs/common';",
+        `import { aventaraResources } from '${specifier(CONFIG_FILE, resourcesTreeBeside(artifact), js)}';`,
+        "",
+        "const logger = new Logger('Aventara');",
+        "",
+        "/**",
+        " * Aventara's configuration: where the API is mounted (`api`), and what you add",
+        " * to it (`exposed` and `exemptions`, `pipelines`, and the per-Resource",
+        " * `resources` tree).",
+        " * AventaraModule (app.module.ts) builds the framework from it and the adapter",
+        " * (src/aventara.adapter.ts). aventara-build, in the aventara:prepare script,",
+        " * runs this file to compile its Contracts, so keep its top level free of side",
+        " * effects: no connection, no request.",
+        " */",
+        "export const aventaraConfig = {",
+        `  api: '${SCAFFOLD_API}',`,
+        "  // Everything the adapter offers is exposed. List what to hide under",
+        "  // `exemptions`, or set `exposed: false` and list what to expose instead.",
+        `  // See: ${EXPOSURE_DOCS}`,
+        "  exposed: true,",
+        "  // Every Resource you define with defineResource() in its own file under",
+        "  // src/resources/ (named <name>.resource.ts), gathered by aventara-build in",
+        "  // the aventara:prepare script: a new Resource file needs no line here. When",
+        "  // a Resource gives a layer a block, that layer takes its tree once, e.g.",
+        "  //   client: { resources: aventaraResources.client },",
+        "  resources: aventaraResources.root,",
+        "  // When something fails inside the server, the caller gets a plain 500 and",
+        "  // Aventara logs one line naming the request. This logs the error itself,",
+        "  // with its stack, through Nest's logger.",
+        "  diagnostics: (diagnostic: AvDiagnostic) => {",
+        "    const { error } = diagnostic;",
+        "    logger.error(",
+        `      \`\${diagnostic.code} (request \${diagnostic.requestId}): raw error\`,`,
+        "      error instanceof Error ? error.stack : String(error),",
+        "    );",
+        "  },",
+        "} as const;",
+        "",
+    ].join("\n");
+}
+function aventaraAdapter(input) {
+    return [
+        `import { describePrismaAdapter } from '${input.entry.adapterPackage}';`,
+        `import { discovery } from '${discoveryImport(ADAPTER_FILE, input.artifact, input.js)}';`,
+        "",
+        "/**",
+        " * The Prisma adapter's description: your schema's model, as the aventara:prepare",
+        " * script discovered it (`discovery`), and the database it runs on. aventara-build",
+        " * compiles the Contracts from it; app.module.ts builds the adapter from it with",
+        " * the Prisma client.",
+        " */",
+        "export default describePrismaAdapter({",
+        "  discovery,",
+        `  provider: '${input.provider}',`,
+        `  driver: '${input.entry.drivers[input.provider]}',`,
+        "});",
+        "",
+    ].join("\n");
+}
+function appModule(service, module, adapterPackage, js) {
+    const from = "src/app.module.ts";
+    const sameFile = service.file === module.file;
+    return {
+        imports: [
+            `import { createPrismaAdapter } from '${adapterPackage}';`,
+            `import adapter from '${specifier(from, ADAPTER_FILE.replace(/\.ts$/, ""), js)}';`,
+            `import { aventaraConfig } from '${specifier(from, CONFIG_FILE.replace(/\.ts$/, ""), 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: {",
+                "      ...aventaraConfig,",
+                "      adapter: await createPrismaAdapter({",
+                "        ...adapter,",
+                service.clientMember === undefined
+                    ? "        client: prisma,"
+                    : `        client: prisma.${service.clientMember},`,
+                "      }),",
+                "    },",
+                "  }),",
+                "}),",
+            ].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 = `${NEST.layout.generated}/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: CONFIG_FILE, content: aventaraConfig(js, artifact) },
+            {
+                path: ADAPTER_FILE,
+                content: aventaraAdapter({ ...input, artifact, js }),
+            },
+        ],
+        env: { DATABASE_URL: provider.databaseUrl },
+        gitignore: ["/src/generated/", ...provider.gitignore],
+        dependencies: { [input.entry.orm.package]: floor, [driver]: floor },
+        devDependencies: { prisma: floor },
+        prepare: prepare({
+            ...input,
+            schema: SCHEMA,
+            clientOutput: CLIENT_OUTPUT,
+            artifact,
+            configFile: CONFIG_FILE,
+        }),
+        appModule: appModule(NEW_SERVICE, NEW_MODULE, input.entry.adapterPackage, 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: CONFIG_FILE, content: aventaraConfig(js, input.artifact) },
+            {
+                path: ADAPTER_FILE,
+                content: aventaraAdapter({
+                    entry: input.entry,
+                    provider: facts.provider,
+                    artifact: input.artifact,
+                    js,
+                }),
+            },
+        ],
+        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,
+            configFile: CONFIG_FILE,
+        }),
+        appModule: appModule(input.service, input.module, input.entry.adapterPackage, js),
+        nativeBuilds: [],
+        nextSteps: [],
+    };
+}
+export const PRISMA7_NEST_TEMPLATES = {
+    scaffold,
+    newService: { service: NEW_SERVICE, module: NEW_MODULE },
+    reuse,
+};

package/dist/templates/prisma7/prisma7-next.templates.js

@@ -0,0 +1,182 @@
+import { hostOf } from "../../catalog/host-entry.interface.js";
+import { lowestVersionOf } from "../../catalog/range.reader.js";
+import { EXPOSURE_DOCS } from "../docs.links.js";
+import { SERVER_ENTRY } from "../next-server.entry.js";
+import { SCAFFOLD_API, } from "../template.registry.js";
+import { CLIENT_OUTPUT, discoveryImport, PROVIDERS, prepare, prismaConfig, resourcesTreeBeside, SCHEMA, schema, specifier, } from "./prisma7-orm.templates.js";
+const NEXT = hostOf("next");
+const CONFIG_FILE = `${NEXT.layout.config}.ts`;
+const ADAPTER_FILE = `${NEXT.layout.adapter}.ts`;
+const SERVER_FILE = SERVER_ENTRY;
+const CLIENT_MODULE = "src/prisma.ts";
+const JS = "";
+function prismaClientModule(input) {
+    const provider = PROVIDERS[input.provider];
+    const driver = input.entry.drivers[input.provider];
+    return [
+        `import { ${provider.driverClass} } from "${driver}";`,
+        `import { PrismaClient } from "${specifier(CLIENT_MODULE, `${CLIENT_OUTPUT}/client`, JS)}";`,
+        "",
+        "const globalForPrisma = globalThis as typeof globalThis & {",
+        "  prisma?: PrismaClient;",
+        "};",
+        "",
+        "/**",
+        " * The app's one PrismaClient, made on first use: importing this module connects",
+        " * to nothing. It is kept on globalThis, so a reload in `next dev` reuses it",
+        " * instead of opening another connection.",
+        " */",
+        "export function prisma(): PrismaClient {",
+        "  if (globalForPrisma.prisma === undefined) {",
+        "    const url = process.env.DATABASE_URL;",
+        "    if (!url) {",
+        "      throw new Error(",
+        '        "DATABASE_URL is not set: put it in .env (Next.js loads it) or in the environment.",',
+        "      );",
+        "    }",
+        "    globalForPrisma.prisma = new PrismaClient({",
+        `      adapter: new ${provider.driverClass}(${provider.driverOptions}),`,
+        "    });",
+        "  }",
+        "  return globalForPrisma.prisma;",
+        "}",
+        "",
+    ].join("\n");
+}
+function aventaraConfig(artifact) {
+    return [
+        'import type { AvDiagnostic } from "@aventara/core";',
+        `import { aventaraResources } from "${specifier(CONFIG_FILE, resourcesTreeBeside(artifact), JS)}";`,
+        "",
+        "/**",
+        " * Aventara's configuration: where the API is mounted (`api`), and what you add",
+        " * to it (`exposed` and `exemptions`, `pipelines`, and the per-Resource",
+        " * `resources` tree).",
+        " * server.ts builds the framework from it and the adapter (adapter.ts).",
+        " * aventara-build, in the aventara:prepare script, runs this file to compile its",
+        " * Contracts and write the browser client, so keep its top level free of side",
+        " * effects: no connection, no request.",
+        " */",
+        "export const aventaraConfig = {",
+        "  // The route files under src/app/api/[...aventara]/ serve it: keep the two in step.",
+        `  api: "${SCAFFOLD_API}",`,
+        "  // Everything the adapter offers is exposed. List what to hide under",
+        "  // `exemptions`, or set `exposed: false` and list what to expose instead.",
+        `  // See: ${EXPOSURE_DOCS}`,
+        "  exposed: true,",
+        "  // Every Resource you define with defineResource() in its own file under",
+        "  // src/resources/ (named <name>.resource.ts), gathered by aventara-build in",
+        "  // the aventara:prepare script: a new Resource file needs no line here. When",
+        "  // a Resource gives a layer a block, that layer takes its tree once, e.g.",
+        "  //   client: { resources: aventaraResources.client },",
+        "  resources: aventaraResources.root,",
+        "  // When something fails inside the server, the caller gets a plain 500 and",
+        "  // Aventara logs one line naming the request. This logs the error itself,",
+        "  // with its stack, on the server's console.",
+        "  diagnostics: (diagnostic: AvDiagnostic) => {",
+        "    const { error } = diagnostic;",
+        "    console.error(",
+        `      \`Aventara \${diagnostic.code} (request \${diagnostic.requestId}): raw error\`,`,
+        "      error instanceof Error ? error.stack : String(error),",
+        "    );",
+        "  },",
+        "} as const;",
+        "",
+    ].join("\n");
+}
+function aventaraAdapter(input, artifact) {
+    return [
+        `import { describePrismaAdapter } from "${input.entry.adapterPackage}";`,
+        `import { discovery } from "${discoveryImport(ADAPTER_FILE, artifact, JS)}";`,
+        "",
+        "/**",
+        " * The Prisma adapter's description: your schema's model, as the aventara:prepare",
+        " * script discovered it (`discovery`), and the database it runs on. aventara-build",
+        " * compiles the Contracts from it; server.ts builds the adapter from it with the",
+        " * Prisma client.",
+        " */",
+        "export default describePrismaAdapter({",
+        "  discovery,",
+        `  provider: "${input.provider}",`,
+        `  driver: "${input.entry.drivers[input.provider]}",`,
+        "});",
+        "",
+    ].join("\n");
+}
+function serverEntry(input, artifact) {
+    const generated = artifact.replace(/[^/]+$/, "");
+    return [
+        'import "server-only";',
+        'import { Aventara } from "@aventara/next";',
+        `import { createPrismaAdapter } from "${input.entry.adapterPackage}";`,
+        `import { prisma } from "${specifier(SERVER_FILE, CLIENT_MODULE.replace(/\.ts$/, ""), JS)}";`,
+        `import adapter from "${specifier(SERVER_FILE, ADAPTER_FILE.replace(/\.ts$/, ""), JS)}";`,
+        `import { aventaraConfig } from "${specifier(SERVER_FILE, CONFIG_FILE.replace(/\.ts$/, ""), JS)}";`,
+        `import { aventaraContracts } from "${specifier(SERVER_FILE, `${generated}contracts.generated`, JS)}";`,
+        "",
+        "/**",
+        ' * Aventara on this app\'s server. Import it as "@/aventara/server", from server',
+        " * code only:",
+        " * - handlers: the route handlers src/app/api/[...aventara]/route.ts exports;",
+        " * - avClient: the client layer, for Server Components and Server Actions;",
+        " *   the policy checks it as the caller `state` describes;",
+        " * - avApp: the application layer, for trusted server code;",
+        " * - ready(): builds the framework; src/instrumentation.ts awaits it at startup,",
+        " *   so a bad configuration stops `next start`.",
+        " */",
+        "export const { handlers, avClient, avApp, ready } = Aventara({",
+        "  ...aventaraConfig,",
+        "  // Built on first use, never when a module is imported.",
+        "  adapter: () => createPrismaAdapter({ ...adapter, client: prisma() }),",
+        "  // In production, the Contracts aventara:prepare compiled (next build runs it",
+        "  // first); in development they are compiled at startup.",
+        "  prebuilt:",
+        '    process.env.NODE_ENV === "production" ? aventaraContracts : undefined,',
+        "  // Each request's ctx.$state, read from its headers, such as the signed-in",
+        "  // user the policy checks:",
+        "  //   state: async ({ headers }) => ({ user: await userFrom(headers) }),",
+        "});",
+        "",
+    ].join("\n");
+}
+function scaffold(input) {
+    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 = `${NEXT.layout.generated}/discovery.artifact.ts`;
+    return {
+        files: [
+            {
+                path: SCHEMA,
+                content: schema({ ...input, moduleKind: "esm" }),
+            },
+            { path: "prisma.config.ts", content: prismaConfig() },
+            { path: CLIENT_MODULE, content: prismaClientModule(input) },
+            { path: CONFIG_FILE, content: aventaraConfig(artifact) },
+            { path: ADAPTER_FILE, content: aventaraAdapter(input, artifact) },
+            { path: SERVER_FILE, content: serverEntry(input, artifact) },
+        ],
+        env: { DATABASE_URL: provider.databaseUrl },
+        gitignore: ["/src/generated/", ...provider.gitignore],
+        dependencies: { [input.entry.orm.package]: floor, [driver]: floor },
+        devDependencies: { prisma: floor },
+        prepare: prepare({
+            ...input,
+            schema: SCHEMA,
+            clientOutput: CLIENT_OUTPUT,
+            artifact,
+            configFile: CONFIG_FILE,
+        }),
+        nativeBuilds: provider.nativeBuilds,
+        nextSteps: [
+            ...(input.provider === "postgresql"
+                ? ["Set DATABASE_URL in .env to your PostgreSQL database."]
+                : []),
+            `Create the database tables: ${run} prisma db push`,
+        ],
+    };
+}
+export const PRISMA7_NEXT_TEMPLATES = {
+    scaffold,
+};

package/dist/templates/prisma7/prisma7-orm.templates.js

@@ -0,0 +1,180 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+export const CLIENT_OUTPUT = "src/generated/prisma";
+export const SCHEMA = "prisma/schema.prisma";
+export function resourcesTreeBeside(artifact) {
+    return `${path.posix.dirname(artifact)}/resources.generated`;
+}
+const CONFIG_FILES = ["prisma7.config.ts", "prisma.config.ts"];
+const DRIVER_PREFIX = "@prisma/adapter-";
+export const PROVIDERS = {
+    sqlite: {
+        driverClass: "PrismaBetterSqlite3",
+        driverOptions: "{ url }",
+        databaseUrl: "file:./dev.db",
+        gitignore: ["/dev.db*"],
+        nativeBuilds: ["@prisma/engines", "better-sqlite3", "prisma"],
+    },
+    postgresql: {
+        driverClass: "PrismaPg",
+        driverOptions: "{ connectionString: url }",
+        databaseUrl: "postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public",
+        gitignore: [],
+        nativeBuilds: ["@prisma/engines", "prisma"],
+    },
+};
+export function specifier(from, to, js) {
+    const relative = path.posix.relative(path.posix.dirname(from), to);
+    return `${relative.startsWith(".") ? relative : `./${relative}`}${js}`;
+}
+export function schema(input) {
+    return [
+        "generator client {",
+        `  provider = "${input.entry.generators[0]}"`,
+        `  output   = "../${CLIENT_OUTPUT}"`,
+        ...(input.moduleKind === "cjs" ? ['  moduleFormat = "cjs"'] : []),
+        "}",
+        "",
+        "datasource db {",
+        `  provider = "${input.provider}"`,
+        "}",
+        "",
+        "model User {",
+        "  id    Int     @id @default(autoincrement())",
+        "  email String  @unique",
+        "  name  String?",
+        "}",
+        "",
+    ].join("\n");
+}
+export 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");
+}
+export function discoveryImport(adapterFile, artifact, js) {
+    return specifier(adapterFile, artifact.replace(/\.ts$/, ""), js);
+}
+export 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}`,
+        `--config ${input.configFile}`,
+    ].join(" ");
+}
+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;
+}
+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];
+}
+export 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");
+            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)),
+    };
+}
+export 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],
+    };
+}