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

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

@@ -1,416 +1,12 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-import { lowestVersionOf } from "../../catalog/range.reader.js";
-import { EXPOSURE_DOCS } from "../docs.links.js";
-import { SCAFFOLD_API, } from "../template.registry.js";
-const CLIENT_OUTPUT = "src/generated/prisma";
-const SCHEMA = "prisma/schema.prisma";
-const CONFIG_FILE = "src/aventara.config.ts";
-const ADAPTER_FILE = "src/aventara.adapter.ts";
-function resourcesTreeBeside(artifact) {
-    return `${path.posix.dirname(artifact)}/resources.generated`;
-}
-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*"],
-        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"],
-    },
-};
-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}"`,
-        "}",
-        "",
-        "model User {",
-        "  id    Int     @id @default(autoincrement())",
-        "  email String  @unique",
-        "  name  String?",
-        "}",
-        "",
-    ].join("\n");
-}
-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");
-}
-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 '${specifier(ADAPTER_FILE, input.artifact.replace(/\.ts$/, ""), 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 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 ${CONFIG_FILE}`,
-    ].join(" ");
-}
-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 = "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: 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,
-        }),
-        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,
-        }),
-        appModule: appModule(input.service, input.module, input.entry.adapterPackage, js),
-        nativeBuilds: [],
-        nextSteps: [],
-    };
-}
-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];
-}
-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)),
-    };
-}
-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],
-    };
-}
+import { PRISMA7_NEST_TEMPLATES } from "./prisma7-nest.templates.js";
+import { PRISMA7_NEXT_TEMPLATES } from "./prisma7-next.templates.js";
+import { clientShape, PROVIDERS, readProject, } from "./prisma7-orm.templates.js";
 export const PRISMA7_TEMPLATES = {
     providers: PROVIDERS,
-    scaffold,
     readProject,
     clientShape,
-    newService: { service: NEW_SERVICE, module: NEW_MODULE },
-    reuse,
+    hosts: {
+        nest: PRISMA7_NEST_TEMPLATES,
+        next: PRISMA7_NEXT_TEMPLATES,
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/cli",
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0-rc.9",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Scaffolds an Aventara server: `aventara new` for a new NestJS project, `aventara init` for an existing one.",
   "type": "module",
@@ -23,7 +23,7 @@
     "typescript": "^5.9.2"
   },
   "scripts": {
-    "prebuild": "node scripts/adapter-catalog.generator.ts && node scripts/agent-skill.generator.ts",
+    "prebuild": "node scripts/adapter-catalog.generator.ts && node ../../scripts/build/host-catalog.generator.ts --out src/catalog/host.catalog.generated.ts && node scripts/agent-skill.generator.ts",
     "build": "node ../../scripts/build/build-output.cleaner.ts dist && tsc -p tsconfig.json --removeComments",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
     "test": "vitest run --typecheck --config ../../vitest.config.mts --root .",