@aventara/prisma7-adapter 0.1.0-pilot.1 → 0.1.0-pilot.2

package/dist/discovery/schema.reader.js

@@ -3,7 +3,6 @@ import path from "node:path";
 export class PrismaSchemaReaderError extends Error {
     name = "PrismaSchemaReaderError";
 }
-/** Field attributes this reader models. Anything else is recorded, not dropped. */
 const FIELD_ATTRIBUTES = new Set([
     "@id",
     "@unique",
@@ -12,9 +11,7 @@ const FIELD_ATTRIBUTES = new Set([
     "@relation",
     "@ignore",
 ]);
-/** Block attributes this reader models. */
 const BLOCK_ATTRIBUTES = new Set(["@@id", "@@unique", "@@ignore"]);
-/** `@relation` arguments this reader models. A positional argument is the name. */
 const RELATION_ARGUMENTS = new Set([
     "name",
     "fields",
@@ -22,23 +19,7 @@ const RELATION_ARGUMENTS = new Set([
     "onDelete",
     "onUpdate",
 ]);
-/**
- * Bucket 2 at `@relation`'s argument level. `map:` names the foreign-key
- * CONSTRAINT — measured at 7.10.0, `@relation(…, map: "beta_alpha_fk")` renders
- * `ALTER TABLE "B" ADD CONSTRAINT "beta_alpha_fk" FOREIGN KEY …`, and that name
- * appears nowhere else. It fails the surface test and the reason behind it
- * alike, which is what separates it from `onDelete`/`onUpdate` on the same
- * attribute.
- */
 const DISCARDED_RELATION_ARGUMENTS = new Set(["map"]);
-/**
- * PSL's referential-action spellings, renamed into Aventara's words. PSL writes
- * the SQL-standard set in PascalCase, so this is a rename, not a translation,
- * and no Prisma spelling travels with the fact.
- *
- * A sixth spelling is bucket 3 rather than a guess: an action this reader cannot
- * name is an action a planner would silently mis-plan around.
- */
 const REFERENTIAL_ACTIONS = {
     Cascade: "cascade",
     Restrict: "restrict",
@@ -46,45 +27,10 @@ const REFERENTIAL_ACTIONS = {
     SetNull: "set-null",
     SetDefault: "set-default",
 };
-/**
- * **Bucket 2 — recognised and deliberately discarded.** DB-naming and
- * physical-layout concerns with no Aventara vocabulary at all.
- *
- * The list is explicit on purpose: the discard is then a decision a reader can
- * see and audit, not an omission. Bucket 1 is `FIELD_ATTRIBUTES`,
- * `BLOCK_ATTRIBUTES`, `@db.*` and `RELATION_ARGUMENTS`; bucket 3 is everything
- * on neither list, which is recorded in `unhandled` and stops the build.
- */
 const DISCARDED_ATTRIBUTES = new Set(["@map", "@@map", "@@index"]);
-/**
- * Bucket 2 at argument level: the named arguments of a **handled** block
- * attribute that this reader discards. `map:`'s index name is the only one —
- * measured at 7.10.0, it reaches nothing but the 🛑 `internal/class.ts`
- * inline-schema blob, so no value of it can ever be observed through Aventara.
- *
- * `name:` was on this list and is **not** any more (2026-09-29): a custom name
- * REPLACES the positional compound alias in `WhereUniqueInput` and in the
- * `AtLeast` key union, so it is a public-API fact, it is modelled
- * ({@link PrismaSchemaBlockIdentifier}), and this list is where discarding it
- * silently broke addressing for every named identifier.
- *
- * An argument on neither this list nor `@@id`/`@@unique`'s modelled set is
- * bucket 3.
- */
 const DISCARDED_BLOCK_ATTRIBUTE_ARGUMENTS = new Set(["map"]);
-/** The named arguments of `@@id`/`@@unique` this reader models, besides the list. */
 const BLOCK_IDENTIFIER_ARGUMENTS = new Set(["name"]);
-/**
- * The argument name under which `@@id`/`@@unique` may carry its member list.
- *
- * PSL accepts the SAME list positionally or named — `@@unique([b, a])` and
- * `@@unique(fields: [b, a])` are one constraint, and a generated client keys both
- * `b_a` (verified with `prisma validate` and a generated client at 7.10.0,
- * 2026-09-29). Which spelling is used is therefore not a fact about the schema,
- * and no argument here is located by POSITION.
- */
 const BLOCK_IDENTIFIER_LIST_ARGUMENT = "fields";
-/** A member this reader can locate: a field name and nothing else. */
 const PLAIN_NAME = /^[A-Za-z_]\w*$/;
 const BLOCK_KEYWORDS = new Set([
     "model",
@@ -94,10 +40,6 @@ const BLOCK_KEYWORDS = new Set([
     "type",
     "view",
 ]);
-/**
- * Reads a schema file, or a schema **folder** (Prisma 7 accepts either).
- * A folder is read as readdir-plus-merge in filename order.
- */
 export async function readPrismaSchema(location) {
     const stats = await stat(location).catch((cause) => {
         throw new PrismaSchemaReaderError(`the Prisma schema at ${location} could not be read`, { cause });
@@ -117,10 +59,6 @@ export async function readPrismaSchema(location) {
     }
     return readPrismaSchemaSources(sources);
 }
-/**
- * The reader proper, over text already in hand. Merging several sources is
- * concatenation: blocks are file-local and references are by name.
- */
 export function readPrismaSchemaSources(sources) {
     const enums = [];
     const models = [];
@@ -133,17 +71,9 @@ export function readPrismaSchemaSources(sources) {
 function readOneSource(source, enums, models, unhandled) {
     let open = null;
     const lines = source.text.split("\n");
-    // Relations whose action argument this reader could not NAME. They are
-    // recorded in `unhandled` and must not then be handed a default: a resolved
-    // action is a claim about what a delete does, and the reader has just said it
-    // does not know. Kept beside the facts rather than on them, so the public
-    // shape carries no "unreadable" state that no consumer can ever observe (a
-    // non-empty `unhandled` fails the generate step first).
     const unreadableActions = new Set();
     for (const [index, raw] of lines.entries()) {
         const site = { file: source.file, line: index + 1 };
-        // Comments go first, and go away string-aware: `"a, b // not a comment"`
-        // carries a `//` that is data, not a comment.
         const line = stripComment(raw).trim();
         if (line.length === 0) {
             continue;
@@ -168,9 +98,6 @@ function readOneSource(source, enums, models, unhandled) {
             else if (open.kind === "model") {
                 models.push({
                     name: open.name,
-                    // Defaults resolve HERE and not on the field line: the default
-                    // turns on the foreign key's optionality, and a `@relation` may
-                    // name a scalar declared below it.
                     fields: resolvePrismaReferentialDefaults(open.fields, unreadableActions),
                     blockId: open.blockId,
                     blockUniques: open.blockUniques,
@@ -185,8 +112,6 @@ function readOneSource(source, enums, models, unhandled) {
             continue;
         }
         if (open.kind === "enum") {
-            // An enum body carries members and block attributes. `@@map` on the enum
-            // is bucket 2 like every other `@@map`; anything else `@@` is bucket 3.
             if (line.startsWith("@@")) {
                 for (const attribute of splitAttributes(line)) {
                     const name = attributeName(attribute);
@@ -196,9 +121,6 @@ function readOneSource(source, enums, models, unhandled) {
                 }
                 continue;
             }
-            // A member is a name, optionally followed by attributes. A member-level
-            // `@map` falls into bucket 2 and is no longer a special case, so the
-            // attributes are located only far enough to find where the name ends.
             const attributes = splitAttributes(line);
             const name = line.slice(0, firstTopLevelAt(line) ?? line.length).trim();
             if (!/^[A-Za-z_]\w*$/.test(name)) {
@@ -254,7 +176,6 @@ function openBlock(line, site, record) {
         return { kind: "enum", name, site, values: [] };
     }
     if (keyword === "type" || keyword === "view") {
-        // Modelling these would be evaluating, not locating (see the header).
         record("block", keyword, line);
     }
     return { kind: "skip", name };
@@ -262,16 +183,12 @@ function openBlock(line, site, record) {
 function readBlockAttributeLine(line, open, record) {
     const attributes = splitAttributes(line);
     if (attributes.length !== 1) {
-        // `prisma validate` rejects two block attributes on one line with P1012
-        // (case 3 in the header), so this is unreachable through the real tool.
-        // It is recorded rather than assumed away.
         record("line", "block-attribute-line", line);
         return;
     }
     const attribute = attributes[0];
     const name = attributeName(attribute);
     if (DISCARDED_ATTRIBUTES.has(name)) {
-        // Bucket 2. `@@map` and `@@index` are DB-naming and physical-layout only.
         return;
     }
     if (!BLOCK_ATTRIBUTES.has(name)) {
@@ -282,21 +199,6 @@ function readBlockAttributeLine(line, open, record) {
         open.ignored = true;
         return;
     }
-    // Every argument is classified BY NAME, never by position. PSL writes the
-    // member list either positionally or as `fields:`, and lets the named
-    // arguments come in any order; all eight spellings of `@@unique` and all five
-    // of `@@id` are accepted by `prisma validate` 7.10.0 (measured 2026-09-29).
-    // Reading the list as "the first argument" is what made the reader take
-    // `@@unique(fields: [b, a])` as one member called `fields: [b, a]`, silently,
-    // and the generate step then refused a schema Prisma accepts.
-    //
-    // The other arguments are classified, not skipped: `name:` is modelled (its
-    // value is an `AtLeast` key), `map:` is bucket 2 (invisible on the 🟢
-    // surface), and an argument spelling this reader has never seen is bucket 3
-    // and stops the build.
-    //
-    // Member order follows THE ATTRIBUTE'S LIST, never the field declaration
-    // order: `@@unique([y, x])` is `["y", "x"]` even where `x` is declared first.
     let members = null;
     let unlocatable = false;
     let alias = null;
@@ -305,8 +207,6 @@ function readBlockAttributeLine(line, open, record) {
         const key = keyed?.[1];
         const value = keyed?.[2] ?? argument;
         if (key === undefined || key === BLOCK_IDENTIFIER_LIST_ARGUMENT) {
-            // The positional argument IS the member list, and `fields:` is that
-            // same list named; PSL rejects a declaration carrying both.
             const located = listMembers(value);
             if (located === null) {
                 unlocatable = true;
@@ -316,8 +216,6 @@ function readBlockAttributeLine(line, open, record) {
             continue;
         }
         if (BLOCK_IDENTIFIER_ARGUMENTS.has(key)) {
-            // Located and unquoted, never evaluated: PSL writes it as a string
-            // literal and Prisma spells the key with exactly those characters.
             alias = unquote(value);
             continue;
         }
@@ -326,11 +224,6 @@ function readBlockAttributeLine(line, open, record) {
         }
     }
     if (members === null || unlocatable) {
-        // Bucket 3, and deliberately not a guess: a member spelled `a(sort: Desc)`
-        // — valid PSL at 7.10.0 — cannot be reduced to a field name without
-        // EVALUATING it, which this reader does not do. Recorded, so the generate
-        // step stops loudly rather than emitting an identifier over a column no
-        // `AdapterFieldMap` carries.
         record("block-attribute", name, attribute);
         return;
     }
@@ -349,8 +242,6 @@ function readFieldLine(line, site, record, unreadableActions) {
     const name = tokens[0];
     const written = tokens[1];
     if (tokens.length !== 2 || name === undefined || written === undefined) {
-        // `prisma validate` rejects a split field declaration with P1012 (case 4 in
-        // the header), so this is unreachable through the real tool.
         record("line", "field-declaration", line);
         return null;
     }
@@ -369,14 +260,10 @@ function readFieldLine(line, site, record, unreadableActions) {
         : splitAttributes(line.slice(attributeStart))) {
         const attributeName_ = attributeName(attribute);
         if (attributeName_.startsWith("@db.")) {
-            // A hint only, kept exactly as written.
             native.push(attribute);
             continue;
         }
         if (DISCARDED_ATTRIBUTES.has(attributeName_)) {
-            // Bucket 2. A field-level `@map` names a column; Aventara has no
-            // vocabulary for a column name, and recording it here would fail the
-            // generate step on most real Prisma schemas.
             continue;
         }
         if (!FIELD_ATTRIBUTES.has(attributeName_)) {
@@ -397,7 +284,6 @@ function readFieldLine(line, site, record, unreadableActions) {
                 ignored = true;
                 break;
             case "@default":
-                // RAW TEXT. Matched against a table downstream, never parsed here.
                 defaultArgument = argumentText(attribute);
                 break;
             default:
@@ -430,15 +316,12 @@ function readRelationAttribute(attribute, record, unreadableActions) {
     for (const argument of splitTopLevel(argumentText(attribute) ?? "", ",")) {
         const keyed = /^([A-Za-z_]\w*)\s*:\s*([\s\S]*)$/.exec(argument);
         if (keyed === null) {
-            // A positional argument is the relation name — the ONLY evidence
-            // pairing a back-reference with its forward reference.
             name = unquote(argument);
             continue;
         }
         const key = keyed[1];
         const value = keyed[2].trim();
         if (DISCARDED_RELATION_ARGUMENTS.has(key)) {
-            // Bucket 2: a foreign-key constraint name, and nothing else.
             continue;
         }
         if (!RELATION_ARGUMENTS.has(key)) {
@@ -450,8 +333,6 @@ function readRelationAttribute(attribute, record, unreadableActions) {
             continue;
         }
         if (key === "onDelete" || key === "onUpdate") {
-            // Located, then renamed through a closed table. An enum member is
-            // written bare in PSL, so this is a lookup and not an evaluation.
             const action = REFERENTIAL_ACTIONS[value];
             if (action === undefined) {
                 record("attribute-argument", key, argument);
@@ -466,9 +347,6 @@ function readRelationAttribute(attribute, record, unreadableActions) {
             }
             continue;
         }
-        // `fields:`/`references:` are located the same way the block attributes'
-        // list is, and by the same rule: a member this reader cannot reduce to a
-        // field name without evaluating it is bucket 3, not a guess.
         const located = listMembers(value);
         if (located === null) {
             record("attribute-argument", key, argument);
@@ -493,40 +371,10 @@ function readRelationAttribute(attribute, record, unreadableActions) {
     }
     return relation;
 }
-/**
- * Absent `onDelete`/`onUpdate` replaced by Prisma's **effective** default, on the
- * owning edges of one model.
- *
- * An absent action and the explicitly-written default are one fact about what a
- * delete does, so there is no third state to carry. What the default IS was
- * measured at 7.10.0 with
- * `prisma migrate diff --from-empty --to-schema <file> --script`, identical on
- * `postgresql` and `sqlite` (2026-09-29):
- *
- * ```text
- *   alphaId String   alpha Alpha   → ON DELETE RESTRICT ON UPDATE CASCADE
- *   alphaId String?  alpha Alpha?  → ON DELETE SET NULL ON UPDATE CASCADE
- *   aId String, aK String?  a A?   → ON DELETE RESTRICT ON UPDATE CASCADE
- * ```
- *
- * The third line is why the discriminant is stated as it is. The plain reading —
- * "a required relation restricts, an optional one nulls" — is wrong: the
- * relation field's own `?` does not decide it. `SET NULL` appears exactly when
- * **every** scalar in `fields:` is optional, which is the only case where the
- * database can actually write the null. A compound key with one required member
- * restricts, and so does an optional relation field over a required foreign key.
- *
- * A foreign key naming no sibling is left non-optional here, which resolves to
- * `restrict`; `field.mapper.ts` throws on that schema before any consumer reads
- * the action.
- */
 function resolvePrismaReferentialDefaults(fields, unreadableActions) {
     const optionalByName = new Map(fields.map((field) => [field.name, field.optional]));
     return fields.map((field) => {
         const relation = field.relation;
-        // `fields:` is what makes an edge the owning side, and PSL forbids the
-        // other side from carrying an action at all — so a back-reference keeps
-        // `null`, which reads as "ask the other edge".
         if (relation === null || relation.fields === null) {
             return field;
         }
@@ -545,11 +393,6 @@ function resolvePrismaReferentialDefaults(fields, unreadableActions) {
         };
     });
 }
-/* ------------------------------------------------------------------ *
- * Locating primitives. Every one of these finds where a token is; not *
- * one of them decides what a token means.                            *
- * ------------------------------------------------------------------ */
-/** Removes a `//` comment, string-aware: a `//` inside a string literal is data. */
 function stripComment(line) {
     let inString = false;
     for (let i = 0; i < line.length; i += 1) {
@@ -573,7 +416,6 @@ function stripComment(line) {
     }
     return line;
 }
-/** The index of the first attribute `@` outside strings and brackets, or null. */
 function firstTopLevelAt(text) {
     for (const index of topLevelAtIndexes(text)) {
         return index;
@@ -604,23 +446,19 @@ function* topLevelAtIndexes(text) {
             depth -= 1;
         }
         else if (ch === "@" && depth === 0 && text[i - 1] !== "@") {
-            // `@@` is one marker, not two attributes.
             yield i;
         }
     }
 }
-/** Splits `@a(1) @@b([x])` into whole attributes, strings and brackets respected. */
 function splitAttributes(text) {
     const starts = [...topLevelAtIndexes(text)];
     return starts
         .map((start, position) => text.slice(start, starts[position + 1] ?? text.length).trim())
         .filter((attribute) => attribute.length > 0);
 }
-/** `@db.Decimal(10, 2)` → `@db.Decimal`; `@@unique([y, x])` → `@@unique`. */
 function attributeName(attribute) {
     return /^@@?[A-Za-z_][\w.]*/.exec(attribute)?.[0] ?? attribute;
 }
-/** The text between an attribute's outermost parentheses, or null when it has none. */
 function argumentText(attribute) {
     const open = attribute.indexOf("(");
     if (open < 0 || !attribute.trimEnd().endsWith(")")) {
@@ -631,17 +469,6 @@ function argumentText(attribute) {
         .slice(open + 1, -1)
         .trim();
 }
-/**
- * A `[…]` argument's members in written order, or **null** when the value is not
- * a list of plain field names.
- *
- * Null is the locator's honest answer, and the caller turns it into an
- * `unhandled` entry. Two shapes reach it, both valid PSL at 7.10.0: a member
- * carrying an argument of its own (`@@unique([a(sort: Desc)])`), and a value that
- * is not a list at all. Either one would have to be EVALUATED to yield a field
- * name, and a reader that guesses here emits an identifier over a column that
- * does not exist — which is exactly how the named-list defect stayed silent.
- */
 function listMembers(value) {
     const trimmed = value.trim();
     if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
@@ -650,7 +477,6 @@ function listMembers(value) {
     const members = splitTopLevel(trimmed.slice(1, -1), ",");
     return members.every((member) => PLAIN_NAME.test(member)) ? members : null;
 }
-/** Splits on a separator at bracket depth 0, outside string literals. */
 function splitTopLevel(text, separator) {
     const out = [];
     let depth = 0;

package/dist/discovery/types.reader.d.ts

@@ -15,10 +15,6 @@ export declare class PrismaTypesReaderError extends Error {
 /**
  * The reader's one checker question, exported because it is the distinction the
  * whole reader rests on and therefore has to be testable on its own.
- *
- * Returns each written type argument's type as the checker renders it, so
- * `FieldRef<"M0", 'String'>` answers `['"M0"', '"String"']` — including when
- * `FieldRef` itself does not resolve.
  */
 export declare function readWrittenTypeArguments(checker: ts.TypeChecker, reference: ts.TypeReferenceNode): readonly string[];
 export declare function readPrismaCapabilitySurface(clientDirectory: string): PrismaTypesReadResult;