@aventara/prisma7-adapter 1.0.0-rc.2 → 1.0.0-rc.3

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @aventara/prisma7-adapter
 
+## 1.0.0-rc.3
+
+### Patch Changes
+
+- b38034d: `aventara-prisma7-generate` refuses a `--provider` that the schema's `datasource` block contradicts, or a block naming
+  a provider the adapter does not support, before `prisma generate` runs, so neither the Prisma client nor the artifact
+  is written:
+
+  ```text
+  aventara-prisma7-generate: --provider postgresql contradicts the schema's datasource `db` (prisma/schema.prisma:12), which names provider "sqlite"; pass --provider sqlite.
+  ```
+
+  PSL's `postgres` spelling counts as `postgresql`, and a provider that is not a string literal is not compared.
+  Before, the flag was taken on trust, and a wrong one wrote the wrong provider into the artifact and the wrong filter
+  modes into the Contract.
+
+  When the file system refuses the artifact file (`--out`), the step says so in one sentence naming the file and why,
+  such as
+  `the artifact file /app/src/generated/aventara/discovery.artifact.ts (--out) cannot be written: permission denied (EACCES).`,
+  and leaves no staged file behind. Before, every such failure except a directory printed a stack trace.
+
+- b38034d: On PostgreSQL, a `@unique` value too long for its index (an index row past the B-tree's 8191 bytes, SQLSTATE
+  `54000`) is answered `422 A2004`, not `500 A3001`: one `V1004` issue at `["arguments"]`, as a value too long for its
+  column already was. The adapter reads the SQLSTATE, never the message. The issue's message for a value too long now
+  reads `The database refused this value: it is longer than the database can hold for its column.`
+  (it said `longer than its column can hold`, which an index refusal is not).
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+  - @aventara/core@1.0.0-rc.3
+
 ## 1.0.0-rc.2
 
 ### Patch Changes

package/README.md

@@ -86,8 +86,9 @@ npx aventara-prisma7-generate \
   --config   src/aventara.config.ts
 ```
 
-`--provider` and `--driver` are declared, never sniffed. The provider is recorded in the artifact. The
-driver decides `AvAdapterModel.transactions`, a driver fact the schema cannot state. Declare the driver
+`--provider` and `--driver` are declared, never sniffed. The provider is recorded in the artifact, and the
+step refuses a `--provider` that the schema's `datasource` block contradicts (`provider = "sqlite"` with
+`--provider postgresql`), naming the flag to pass. The driver decides `AvAdapterModel.transactions`, a driver fact the schema cannot state. Declare the driver
 the application will actually construct the adapter with. The two cannot drift silently, but they can
 disagree, and core refuses construction when they do.
 

package/dist/discovery/schema-facts.interface.d.ts

@@ -26,8 +26,16 @@ export type PrismaSchemaUnknownKind =
  | "block"
 /** A line the reader could not classify at all. */
  | "line";
+/** A `datasource` block: the provider it names. */
+export type PrismaSchemaDatasource = {
+    readonly name: string;
+    readonly provider: string | null;
+    readonly site: PrismaSchemaSite;
+};
 export type PrismaSchemaFacts = {
     readonly enums: readonly PrismaSchemaEnum[];
+    /** Every `datasource` block, in reading order (Prisma admits one). */
+    readonly datasources: readonly PrismaSchemaDatasource[];
     readonly models: readonly PrismaSchemaModel[];
     /**
      * Attributes and blocks the reader does not recognise at all (a `type`/`view`

package/dist/discovery/schema.reader.js

@@ -63,12 +63,15 @@ export function readPrismaSchemaSources(sources) {
     const enums = [];
     const models = [];
     const unhandled = [];
+    const datasources = [];
     for (const source of sources) {
-        readOneSource(source, enums, models, unhandled);
+        readOneSource(source, enums, models, unhandled, datasources);
     }
-    return { enums, models, unhandled };
+    return { enums, datasources, models, unhandled };
 }
-function readOneSource(source, enums, models, unhandled) {
+const DATASOURCE_PROVIDER = /^provider\s*=\s*(.*)$/;
+const STRING_LITERAL = /^"([^"\\]*)"$/;
+function readOneSource(source, enums, models, unhandled, datasources) {
     let open = null;
     const lines = source.text.split("\n");
     const unreadableActions = new Set();
@@ -105,12 +108,26 @@ function readOneSource(source, enums, models, unhandled) {
                     site: open.site,
                 });
             }
+            else if (open.kind === "datasource") {
+                datasources.push({
+                    name: open.name,
+                    provider: open.provider,
+                    site: open.site,
+                });
+            }
             open = null;
             continue;
         }
         if (open.kind === "skip") {
             continue;
         }
+        if (open.kind === "datasource") {
+            const assigned = DATASOURCE_PROVIDER.exec(line)?.[1]?.trim();
+            if (assigned !== undefined) {
+                open.provider = STRING_LITERAL.exec(assigned)?.[1] ?? null;
+            }
+            continue;
+        }
         if (open.kind === "enum") {
             if (line.startsWith("@@")) {
                 for (const attribute of splitAttributes(line)) {
@@ -175,6 +192,9 @@ function openBlock(line, site, record) {
     if (keyword === "enum") {
         return { kind: "enum", name, site, values: [] };
     }
+    if (keyword === "datasource") {
+        return { kind: "datasource", name, site, provider: null };
+    }
     if (keyword === "type" || keyword === "view") {
         record("block", keyword, line);
     }

package/dist/errors/error.normalizer.js

@@ -29,6 +29,7 @@ export const PRISMA_DATABASE_VALUE_TABLE = {
     "22025": "trailingEscape",
     "22009": "datetimeOutOfRange",
     "22012": "divisionByZero",
+    "54000": "tooLong",
 };
 function refusedValue(facts) {
     if (facts.code === undefined) {

package/dist/generate/prisma.generate.js

@@ -5,7 +5,7 @@ import { promisify } from "node:util";
 import ts from "typescript";
 import { computeModelHash } from "../discovery/artifact.loader.js";
 import { DISCOVERY_ARTIFACT_FORMAT } from "../discovery/discovery-artifact.interface.js";
-import { readPrismaSchema } from "../discovery/schema.reader.js";
+import { AvPrismaSchemaReaderError, readPrismaSchema, } from "../discovery/schema.reader.js";
 import { readPrismaCapabilitySurface } from "../discovery/types.reader.js";
 import { emitDiscoveryArtifactModule } from "./artifact.emitter.js";
 import { readConfigComputedFields, } from "./computed-fields.reader.js";
@@ -76,16 +76,38 @@ async function writeArtifactAtomically(file, source) {
     if (current === source) {
         return;
     }
-    await mkdir(path.dirname(file), { recursive: true });
     const staged = `${file}.${process.pid}.${Date.now()}.tmp`;
     try {
+        await mkdir(path.dirname(file), { recursive: true });
         await writeFile(staged, source, "utf8");
         await rename(staged, file);
     }
     catch (error) {
-        await rm(staged, { force: true });
-        throw error;
+        await rm(staged, { force: true }).catch(() => undefined);
+        throw unwritableArtifact(file, error);
+    }
+}
+const UNWRITABLE_BECAUSE = {
+    EACCES: "permission denied",
+    EPERM: "permission denied",
+    ENOTDIR: "a part of its path is a file, not a directory",
+    EEXIST: "a part of its path is a file, not a directory",
+    ENOSPC: "no space is left on the device",
+    EROFS: "the file system is read-only",
+    EISDIR: "it is a directory",
+    ENAMETOOLONG: "its path is too long",
+};
+function unwritableArtifact(file, error) {
+    const code = error instanceof Error && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+    if (code === undefined) {
+        return error;
     }
+    const because = Object.hasOwn(UNWRITABLE_BECAUSE, code)
+        ? `${UNWRITABLE_BECAUSE[code]} (${code})`
+        : code;
+    return new AvPrismaGenerateStepError(`the artifact file ${path.resolve(file)} (--out) cannot be written: ${because}.`);
 }
 async function describesModel(file, modelHash) {
     const current = await readFile(file, "utf8").catch(() => undefined);
@@ -126,6 +148,28 @@ async function assertArtifactPlacement(artifactFile, clientDirectory) {
         throw new AvPrismaGenerateStepError(`the artifact file ${file} (--out) is a directory; name the .ts file to write, such as ${path.join(file, "discovery.artifact.ts")}.`);
     }
 }
+const PSL_PROVIDERS = {
+    sqlite: "sqlite",
+    postgresql: "postgresql",
+    postgres: "postgresql",
+};
+function assertDatasourceProvider(facts, provider) {
+    for (const datasource of facts.datasources) {
+        if (datasource.provider === null) {
+            continue;
+        }
+        const named = Object.hasOwn(PSL_PROVIDERS, datasource.provider)
+            ? PSL_PROVIDERS[datasource.provider]
+            : undefined;
+        if (named === provider) {
+            continue;
+        }
+        const where = `${datasource.site.file}:${datasource.site.line}`;
+        throw new AvPrismaGenerateStepError(named === undefined
+            ? `the schema's datasource \`${datasource.name}\` (${where}) names provider "${datasource.provider}", which this adapter does not support (${Object.keys(PSL_PROVIDERS).join(", ")}).`
+            : `--provider ${provider} contradicts the schema's datasource \`${datasource.name}\` (${where}), which names provider "${datasource.provider}"; pass --provider ${named}.`);
+    }
+}
 function assertNothingUnhandled(facts) {
     if (facts.unhandled.length === 0) {
         return;
@@ -141,6 +185,17 @@ export async function runPrismaGenerateStep(request) {
     const prismaVersion = await toolchain.installedPrismaVersion();
     assertPinnedMajor(prismaVersion);
     assertClientRuntimeResolves(toolchain, request.clientDirectory);
+    const declared = await toolchain
+        .readSchema(request.schema)
+        .catch((error) => {
+        if (error instanceof AvPrismaSchemaReaderError) {
+            return undefined;
+        }
+        throw error;
+    });
+    if (declared !== undefined) {
+        assertDatasourceProvider(declared, request.provider);
+    }
     await toolchain.runPrismaGenerate(request.schema);
     const facts = await toolchain.readSchema(request.schema);
     assertNothingUnhandled(facts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/prisma7-adapter",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.3",
   "license": "SEE LICENSE IN LICENSE",
   "description": "The Prisma 7 adapter for Aventara.",
   "type": "module",
@@ -30,7 +30,7 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "1.0.0-rc.2"
+    "@aventara/core": "1.0.0-rc.3"
   },
   "peerDependencies": {
     "@prisma/adapter-better-sqlite3": "^7.10.0",