@aventara/cli 1.0.0-rc.0 → 1.0.0-rc.10

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

@@ -0,0 +1,189 @@
+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, artifact) {
+    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)}";`,
+        `import { discovery } from "${discoveryImport(CLIENT_MODULE, artifact, JS)}";`,
+        "",
+        "const globalForPrisma = globalThis as typeof globalThis & {",
+        "  prisma?: { readonly client: PrismaClient; readonly schema: string };",
+        "};",
+        "",
+        "/**",
+        " * 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, for as long as the generated schema",
+        " * is the same. After `aventara:prepare` regenerates the client, the next call",
+        " * makes a new one from the new generated class and disconnects the old one.",
+        " */",
+        "export function prisma(): PrismaClient {",
+        "  const kept = globalForPrisma.prisma;",
+        "  if (kept !== undefined && kept.schema === discovery.modelHash) {",
+        "    return kept.client;",
+        "  }",
+        "  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.",',
+        "    );",
+        "  }",
+        "  const client = new PrismaClient({",
+        `    adapter: new ${provider.driverClass}(${provider.driverOptions}),`,
+        "  });",
+        "  globalForPrisma.prisma = { client, schema: discovery.modelHash };",
+        "  kept?.client.$disconnect().catch(() => undefined);",
+        "  return client;",
+        "}",
+        "",
+    ].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, artifact) },
+            { 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],
+    };
+}