@aventara/prisma7-adapter 0.1.0-pilot.0

package/dist/translation/scalar.conversion.js

@@ -0,0 +1,221 @@
+import { Decimal, } from "@aventara/core";
+/**
+ * C-834 — the scalar value conversion, in **one** table and **both**
+ * directions.
+ *
+ * # Why this is a module and not three private helpers
+ *
+ * Three consumers cross the same boundary with the same values: a write's `data`
+ * (`mutation.translator.ts`), a filter operand (`where.translator.ts`) and a row
+ * coming back (`execution/result.shaper.ts`). The emission table was born inside
+ * the mutation translator, which is where the first of the three needed it; a
+ * copy in each consumer would be three places to answer "what does a `decimal`
+ * look like on the wire", and the second copy to drift would be the one nobody
+ * reads. {@link SCALAR_BOUNDARY_CROSSINGS} is therefore the single owner, and
+ * Task 10's `identifier.addressing.ts` is the precedent — extracted for exactly
+ * this reason.
+ *
+ * The table is TOTAL over core's `BuiltInScalar` by a mapped type, so a tenth
+ * scalar added to the protocol is a compile error here rather than a value that
+ * silently crosses unconverted in one direction only.
+ *
+ * # `decimal` is the one real conversion, and that is measured
+ *
+ * Eight of the nine scalars pass through in both directions, re-measured on both
+ * driver adapters at `@prisma/client` 7.10.0 (2026-10-02): a `bigint` primitive,
+ * a `Date` and a `Uint8Array` are what the generated input types accept and what
+ * a read returns (`Buffer.isBuffer(v) === false`, `v instanceof Uint8Array ===
+ * true`), `Json` is written and returned as a plain object (its prototype IS
+ * `Object.prototype`, which is what core's own `isPlainRecord` output check
+ * requires **[CORE, runtime/scalar-runtime.ts]**), and an enum member is its own
+ * name on both sides. Those are the same forms core's runtime scope requires
+ * (`normalizeScalarAtom`'s `"application"` branch), so a pass-through is a
+ * decision, not an omission.
+ *
+ * `decimal` is the exception §6.2 names: *the public `Decimal` MUST NOT be
+ * `Prisma.Decimal`*, and it is not — core's `Decimal` is a class with one
+ * private `#value` and a `toString`, while Prisma's is its bundled decimal.js,
+ * whose constructor is named `Decimal2`. Neither accepts the other, so the
+ * crossing is a real conversion both ways: out, the base-10 string; in, core's
+ * own `Decimal`.
+ *
+ * # Outbound: three different failures, none of them a type error
+ *
+ * Passing core's `Decimal` through unconverted fails *differently* depending on
+ * where it lands, and none of the three is a plain rejection (measured on both
+ * engines, 2026-10-02):
+ *
+ * - as a **write value**: refused at the wire — *"Invalid value for argument
+ *   `toString`: We could not serialize [object Function] value."*;
+ * - as a **comparison operand** (`gt`, `equals`, …): read as a **FieldRef**, not
+ *   as a value — *"PrismaClientValidationError: Argument `_ref` is missing."*;
+ * - as a **bare equality operand**: *accepted*, and silently wrong. Core's
+ *   `Decimal` keeps its digits in a private field, so `Object.keys` is empty and
+ *   Prisma reads the object as an **empty `DecimalFilter`** — `findMany` returned
+ *   **2 of 2** rows, byte-identical to passing no predicate at all, where the
+ *   string `"1"` returned 1. A misinterpretation that validates is the failure
+ *   this module exists to make impossible.
+ *
+ * # Inbound: the value core's output validator will accept
+ *
+ * Core validates adapter output in its `"runtime"` scope, which requires the
+ * *runtime* form of every scalar — `value instanceof Decimal` for a decimal
+ * **[CORE, runtime/output-validator.ts → normalizeScalarFieldValue]**. A
+ * `Decimal2` is not one, so an unconverted read fails core's own validation and
+ * the caller is told `A3000`. Converting here is therefore not a courtesy: it is
+ * the adapter's half of §6.2.
+ *
+ * # The scalar identity comes from the model, never from the value
+ *
+ * Both directions are keyed by the field's discovered scalar, never by the
+ * runtime shape of the value. A `Json` column holding `{ "x": 1 }` and a
+ * `Decimal` reaching Prisma are both "an object", and a `Json` column holding
+ * the string `"12.5"` is indistinguishable from a decimal string: shape-sniffing
+ * would convert one of those sooner or later, and silently. The discovered model
+ * already knows, so it is asked.
+ */
+/** A value this adapter will not convert rather than misrepresent. */
+export class PrismaScalarConversionError extends Error {
+    name = "PrismaScalarConversionError";
+}
+function identity(value) {
+    return value;
+}
+/** A scalar whose Prisma representation IS its Aventara runtime form. */
+const PASS_THROUGH = {
+    outbound: identity,
+    inbound: identity,
+};
+/**
+ * What each Aventara scalar becomes on the way to Prisma and on the way back.
+ *
+ * Total over `BuiltInScalar`: a scalar added to the protocol cannot reach a
+ * provider until both of its directions are decided here.
+ */
+const SCALAR_BOUNDARY_CROSSINGS = {
+    string: PASS_THROUGH,
+    boolean: PASS_THROUGH,
+    int: PASS_THROUGH,
+    float: PASS_THROUGH,
+    bigint: PASS_THROUGH,
+    decimal: { outbound: emitDecimal, inbound: receiveDecimal },
+    datetime: PASS_THROUGH,
+    bytes: PASS_THROUGH,
+    json: PASS_THROUGH,
+};
+/**
+ * Core's `Decimal` → the base-10 string every Prisma decimal input accepts
+ * (`DecimalFieldUpdateOperationsInput` takes `runtime.Decimal | DecimalJsLike |
+ * number | string`, and `DecimalFilter`'s operands the same).
+ *
+ * A value that is not core's `Decimal` is refused rather than coerced: core
+ * normalizes every decimal to its own `Decimal` before the adapter is called
+ * (C-845), so a string or a number arriving here means the request bypassed
+ * validation, and guessing at it would be the adapter inventing precision.
+ */
+function emitDecimal(value, path) {
+    if (value === null) {
+        return null;
+    }
+    if (value instanceof Decimal) {
+        return value.toString();
+    }
+    throw new PrismaScalarConversionError(`${path}: a decimal value reaches the adapter as an Aventara Decimal (core normalizes before the adapter, C-834); the adapter will not guess at a ${describeValue(value)}`);
+}
+/**
+ * Prisma's decimal → core's `Decimal`, which is the only decimal form core's
+ * output validator accepts in its runtime scope.
+ *
+ * The text is read through `String(value)`, which is exactly what RC-10
+ * measured as lossless for 7.10.0's `Decimal2` on both driver adapters
+ * (`String(v) === "12345.6789"`). A text core's own `Decimal` constructor
+ * rejects is reported as a conversion failure naming the form observed, rather
+ * than passed on to fail later as core's generic `A3000`.
+ */
+function receiveDecimal(value, path) {
+    if (value === null) {
+        return null;
+    }
+    if (value instanceof Decimal) {
+        // Already core's: a fake adapter, or a value this adapter round-tripped.
+        return value;
+    }
+    if (typeof value !== "object" &&
+        typeof value !== "string" &&
+        typeof value !== "number") {
+        throw new PrismaScalarConversionError(`${path}: the provider returned ${describeValue(value)} for a decimal column, which the adapter will not read as a decimal`);
+    }
+    const text = String(value);
+    try {
+        return new Decimal(text);
+    }
+    catch {
+        throw new PrismaScalarConversionError(`${path}: the provider returned ${describeValue(value)} for a decimal column, whose text "${text}" is not a decimal core accepts`);
+    }
+}
+/**
+ * One value out of Aventara and into a Prisma argument.
+ *
+ * @throws {PrismaScalarConversionError} for a value the adapter will not
+ * represent rather than let a provider misread.
+ */
+export function emitScalarValue(model, field, value, path) {
+    return convert("outbound", model, field, value, path);
+}
+/**
+ * One value out of a Prisma result and into the runtime form core's output
+ * validator accepts.
+ *
+ * @throws {PrismaScalarConversionError} for a provider value the adapter cannot
+ * honestly read as that scalar.
+ */
+export function receiveScalarValue(model, field, value, path) {
+    return convert("inbound", model, field, value, path);
+}
+function convert(direction, model, field, value, path) {
+    if (!("scalar" in field.type)) {
+        // An enum member is its own name on both sides.
+        return value;
+    }
+    const scalar = field.type.scalar;
+    if (model.scalars[scalar] === undefined) {
+        throw new PrismaScalarConversionError(`${path}: scalar "${scalar}" is not in the discovered registry`);
+    }
+    if (!isBuiltInScalar(scalar)) {
+        throw new PrismaScalarConversionError(`${path}: scalar "${scalar}" has no ${direction} conversion in this adapter`);
+    }
+    return convertAtoms(SCALAR_BOUNDARY_CROSSINGS[scalar][direction], value, path);
+}
+/**
+ * A scalar list's members convert one by one, and the array is rebuilt rather
+ * than written into: a translator that mutated its argument would corrupt the
+ * second attempt of a retried operation, and a shaper that mutated a provider
+ * row would corrupt whatever else holds it.
+ */
+function convertAtoms(crossing, value, path) {
+    if (!Array.isArray(value)) {
+        return crossing(value, path);
+    }
+    let changed = false;
+    const converted = value.map((member, index) => {
+        const result = crossing(member, `${path}[${index}]`);
+        changed ||= result !== member;
+        return result;
+    });
+    // The same array, by identity, when no member needed converting: the shaper's
+    // copy-on-write depends on being able to tell.
+    return changed ? converted : value;
+}
+/** Whether a discovered scalar key is one this adapter has a crossing for. */
+function isBuiltInScalar(key) {
+    return Object.hasOwn(SCALAR_BOUNDARY_CROSSINGS, key);
+}
+/** Names what arrived, without quoting a value that may be large or secret. */
+function describeValue(value) {
+    if (value === null) {
+        return "null";
+    }
+    return typeof value === "object"
+        ? `${value.constructor?.name ?? "object"} instance`
+        : typeof value;
+}

package/dist/translation/where.translator.d.ts

@@ -0,0 +1,79 @@
+import type { AdapterModel } from "@aventara/core";
+/**
+ * T-7 — `where` translation: one validated Aventara predicate in, one Prisma
+ * `<M>WhereInput` out.
+ *
+ * # Pure, and that is the property to protect
+ *
+ * No client, no database, no I/O, no provider name. The only inputs are the
+ * discovered model and plain data, which is what makes the whole filter grammar
+ * exhaustively testable without an engine (T-7's "single largest testability
+ * decision").
+ *
+ * # One direction, and no Prisma token the framework did not ask for
+ *
+ * Every emitted key comes from one of the two tables below, both of which are
+ * TOTAL over core's own capability unions — a member added to
+ * `ScalarFilterOperator` or `RelationFilterCapability` with no row here is a
+ * compile error, not a silently dropped predicate. That is C-855's emission half:
+ * *"capability derivation advertises an argument only when a named translator
+ * step emits it"*, and this module is that step for the filter vocabulary.
+ *
+ * The inverse matters more. A missing key loses a predicate and shows up as a
+ * wrong row count; an INVENTED key silently changes what the query means. So
+ * nothing is ever added to the output that the request did not carry: no `equals`
+ * wrapper around a bare value, no `is`/`isNot` wrapper around a to-one predicate
+ * (§18.5), no `mode` nobody asked for.
+ *
+ * # Values cross the boundary too (C-834)
+ *
+ * A predicate is a key AND an operand, and the operand is a value of the field's
+ * scalar type. Those values go out through `scalar.conversion.ts`, the one table
+ * that knows how each scalar crosses — the same answers `mutation.translator.ts`
+ * uses for a write, because it is the same boundary. {@link SCALAR_FILTER_EMISSIONS}
+ * records, per operator, *whether* its operand is such a value: `in` carries a
+ * list of them, `isEmpty` carries a boolean, `mode` carries a Prisma keyword, and
+ * `path`/`string*`/`array*` carry a position inside a JSON document rather than a
+ * value of the column. Converting indiscriminately would corrupt the second kind;
+ * converting none of them is what let a core `Decimal` reach Prisma, where it was
+ * not rejected but **misread** (measured on both engines, 2026-10-02):
+ *
+ * - `{ sDecimal: { gt: new Decimal("1") } }` → *"PrismaClientValidationError:
+ *   Argument `_ref` is missing."* — Prisma read the object as a **FieldRef**;
+ * - `{ sDecimal: new Decimal("1") }` → **no error and 2 of 2 rows**, the same as
+ *   no predicate at all, because core's `Decimal` keeps its digits in a private
+ *   field and `Object.keys` is therefore empty: Prisma read an **empty
+ *   `DecimalFilter`**. The string `"1"` returned 1 row.
+ *
+ * The second is why the bare-value branch below follows core's own discriminant —
+ * `isPlainRecord`, not "is an object" **[CORE, runtime/scalar-runtime.ts
+ * `normalizeScalarFilter`]**. A class instance is a VALUE; reading one as an
+ * operator record produced `{}`, and an empty filter constrains nothing.
+ *
+ * # Refusing is part of honouring
+ *
+ * The adapter assumes validated input (C-845) and performs no limit checking.
+ * It does, however, refuse to EMIT an operator the discovered model does not
+ * advertise for that field. That is not a second validation pass for the
+ * caller's benefit: it is the mechanism C-855 names — an argument is honoured or
+ * the variant is omitted — enforced at the emission site, so an operator that
+ * discovery decided not to advertise cannot reach a provider by another route.
+ * Core has already rejected such a request with `V1006`; if one ever arrives
+ * here, the model and the Contract have diverged and that is a defect, not a
+ * query.
+ */
+/** A predicate the model does not license, or a key no vocabulary recognises. */
+export declare class PrismaWhereTranslationError extends Error {
+    readonly name = "PrismaWhereTranslationError";
+}
+/** A Prisma `<M>WhereInput`, as plain data. */
+export type PrismaWhereInput = Readonly<Record<string, unknown>>;
+export type WhereTranslation = {
+    /** The discovered model: field kinds, cardinalities, targets and capabilities. */
+    readonly model: AdapterModel;
+    /** The Aventara Resource key the predicate is written against. */
+    readonly resource: string;
+    /** A validated Aventara `WhereInput`, as plain data. */
+    readonly where: unknown;
+};
+export declare function translateWhere(input: WhereTranslation): PrismaWhereInput;

package/dist/translation/where.translator.js

@@ -0,0 +1,254 @@
+import { emitScalarValue } from "./scalar.conversion.js";
+/**
+ * T-7 — `where` translation: one validated Aventara predicate in, one Prisma
+ * `<M>WhereInput` out.
+ *
+ * # Pure, and that is the property to protect
+ *
+ * No client, no database, no I/O, no provider name. The only inputs are the
+ * discovered model and plain data, which is what makes the whole filter grammar
+ * exhaustively testable without an engine (T-7's "single largest testability
+ * decision").
+ *
+ * # One direction, and no Prisma token the framework did not ask for
+ *
+ * Every emitted key comes from one of the two tables below, both of which are
+ * TOTAL over core's own capability unions — a member added to
+ * `ScalarFilterOperator` or `RelationFilterCapability` with no row here is a
+ * compile error, not a silently dropped predicate. That is C-855's emission half:
+ * *"capability derivation advertises an argument only when a named translator
+ * step emits it"*, and this module is that step for the filter vocabulary.
+ *
+ * The inverse matters more. A missing key loses a predicate and shows up as a
+ * wrong row count; an INVENTED key silently changes what the query means. So
+ * nothing is ever added to the output that the request did not carry: no `equals`
+ * wrapper around a bare value, no `is`/`isNot` wrapper around a to-one predicate
+ * (§18.5), no `mode` nobody asked for.
+ *
+ * # Values cross the boundary too (C-834)
+ *
+ * A predicate is a key AND an operand, and the operand is a value of the field's
+ * scalar type. Those values go out through `scalar.conversion.ts`, the one table
+ * that knows how each scalar crosses — the same answers `mutation.translator.ts`
+ * uses for a write, because it is the same boundary. {@link SCALAR_FILTER_EMISSIONS}
+ * records, per operator, *whether* its operand is such a value: `in` carries a
+ * list of them, `isEmpty` carries a boolean, `mode` carries a Prisma keyword, and
+ * `path`/`string*`/`array*` carry a position inside a JSON document rather than a
+ * value of the column. Converting indiscriminately would corrupt the second kind;
+ * converting none of them is what let a core `Decimal` reach Prisma, where it was
+ * not rejected but **misread** (measured on both engines, 2026-10-02):
+ *
+ * - `{ sDecimal: { gt: new Decimal("1") } }` → *"PrismaClientValidationError:
+ *   Argument `_ref` is missing."* — Prisma read the object as a **FieldRef**;
+ * - `{ sDecimal: new Decimal("1") }` → **no error and 2 of 2 rows**, the same as
+ *   no predicate at all, because core's `Decimal` keeps its digits in a private
+ *   field and `Object.keys` is therefore empty: Prisma read an **empty
+ *   `DecimalFilter`**. The string `"1"` returned 1 row.
+ *
+ * The second is why the bare-value branch below follows core's own discriminant —
+ * `isPlainRecord`, not "is an object" **[CORE, runtime/scalar-runtime.ts
+ * `normalizeScalarFilter`]**. A class instance is a VALUE; reading one as an
+ * operator record produced `{}`, and an empty filter constrains nothing.
+ *
+ * # Refusing is part of honouring
+ *
+ * The adapter assumes validated input (C-845) and performs no limit checking.
+ * It does, however, refuse to EMIT an operator the discovered model does not
+ * advertise for that field. That is not a second validation pass for the
+ * caller's benefit: it is the mechanism C-855 names — an argument is honoured or
+ * the variant is omitted — enforced at the emission site, so an operator that
+ * discovery decided not to advertise cannot reach a provider by another route.
+ * Core has already rejected such a request with `V1006`; if one ever arrives
+ * here, the model and the Contract have diverged and that is a defect, not a
+ * query.
+ */
+/** A predicate the model does not license, or a key no vocabulary recognises. */
+export class PrismaWhereTranslationError extends Error {
+    name = "PrismaWhereTranslationError";
+}
+const SCALAR_FILTER_EMISSIONS = {
+    equals: { token: "equals", operand: "value" },
+    not: { token: "not", operand: "value-or-filter" },
+    in: { token: "in", operand: "value-list" },
+    notIn: { token: "notIn", operand: "value-list" },
+    lt: { token: "lt", operand: "value" },
+    lte: { token: "lte", operand: "value" },
+    gt: { token: "gt", operand: "value" },
+    gte: { token: "gte", operand: "value" },
+    contains: { token: "contains", operand: "value" },
+    startsWith: { token: "startsWith", operand: "value" },
+    endsWith: { token: "endsWith", operand: "value" },
+    mode: { token: "mode", operand: "opaque" },
+    has: { token: "has", operand: "value" },
+    hasEvery: { token: "hasEvery", operand: "value-list" },
+    hasSome: { token: "hasSome", operand: "value-list" },
+    isEmpty: { token: "isEmpty", operand: "opaque" },
+    path: { token: "path", operand: "opaque" },
+    stringContains: { token: "string_contains", operand: "opaque" },
+    stringStartsWith: { token: "string_starts_with", operand: "opaque" },
+    stringEndsWith: { token: "string_ends_with", operand: "opaque" },
+    arrayContains: { token: "array_contains", operand: "opaque" },
+    arrayStartsWith: { token: "array_starts_with", operand: "opaque" },
+    arrayEndsWith: { token: "array_ends_with", operand: "opaque" },
+};
+const RELATION_FILTER_EMISSIONS = {
+    nested: { kind: "edge-argument" },
+    match: { kind: "unwrapped" },
+    null: { kind: "null" },
+    some: { kind: "key", token: "some" },
+    every: { kind: "key", token: "every" },
+    none: { kind: "key", token: "none" },
+};
+/** Core's boolean nodes, whose spelling Prisma shares. */
+const BOOLEAN_NODES = { AND: "AND", OR: "OR", NOT: "NOT" };
+export function translateWhere(input) {
+    return translateNode(input.model, input.resource, input.where, "where");
+}
+function translateNode(model, resourceKey, node, path) {
+    const resource = model.resources[resourceKey];
+    if (resource === undefined) {
+        throw new PrismaWhereTranslationError(`${path}: Resource "${resourceKey}" is not in the discovered model`);
+    }
+    if (!isRecord(node)) {
+        throw new PrismaWhereTranslationError(`${path} must be an object`);
+    }
+    const emitted = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (key === BOOLEAN_NODES.AND || key === BOOLEAN_NODES.OR) {
+            if (!Array.isArray(value)) {
+                throw new PrismaWhereTranslationError(`${path}.${key} must be an array of predicates`);
+            }
+            emitted[key] = value.map((member, index) => translateNode(model, resourceKey, member, `${path}.${key}[${index}]`));
+            continue;
+        }
+        if (key === BOOLEAN_NODES.NOT) {
+            // Aventara's `NOT` is ONE node. Prisma admits an array too; emitting one
+            // for a single node would be a shape the request never carried.
+            emitted[key] = translateNode(model, resourceKey, value, `${path}.${key}`);
+            continue;
+        }
+        const field = resource.fields[key];
+        if (field === undefined) {
+            throw new PrismaWhereTranslationError(`${path}.${key} is not a field of Resource "${resourceKey}"`);
+        }
+        emitted[key] =
+            field.kind === "scalar"
+                ? translateScalarPredicate(model, field, value, `${path}.${key}`)
+                : translateRelationPredicate(model, field, value, `${path}.${key}`);
+    }
+    return emitted;
+}
+function translateScalarPredicate(model, field, value, path) {
+    const advertised = field.capabilities.filter;
+    if (advertised === undefined || advertised.length === 0) {
+        throw new PrismaWhereTranslationError(`${path}: filtering is not available on this field`);
+    }
+    // Core's own rule: a value that is not a PLAIN record — `null` and a class
+    // instance included — IS equality, and Prisma spells that the same way.
+    // Wrapping it in `{ equals: … }` would emit a token the request never carried.
+    if (!isPlainRecord(value)) {
+        requireOperator(advertised, "equals", path);
+        return emitScalarValue(model, field, value, path);
+    }
+    const operand = {};
+    for (const [operator, argument] of Object.entries(value)) {
+        if (!isScalarFilterOperator(operator)) {
+            throw new PrismaWhereTranslationError(`${path}.${operator} is not an Aventara filter operator`);
+        }
+        requireOperator(advertised, operator, path);
+        const emission = SCALAR_FILTER_EMISSIONS[operator];
+        operand[emission.token] = emitOperand(model, field, emission.operand, argument, `${path}.${operator}`);
+    }
+    return operand;
+}
+/** One operator's operand, converted as the operator's shape says it must be. */
+function emitOperand(model, field, shape, argument, path) {
+    switch (shape) {
+        case "opaque":
+            return argument;
+        case "value":
+            return emitScalarValue(model, field, argument, path);
+        case "value-list":
+            if (!Array.isArray(argument)) {
+                throw new PrismaWhereTranslationError(`${path} must be an array of values`);
+            }
+            // `emitScalarValue` converts an array elementwise, which is what a list
+            // operand is — and what a LIST column's single value would be too, so the
+            // array is handed over whole rather than mapped here.
+            return emitScalarValue(model, field, argument, path);
+        case "value-or-filter":
+            // Core recurses on `not` exactly when its operand is a plain record, so
+            // the adapter does too; anything else is a value.
+            return isPlainRecord(argument)
+                ? translateScalarPredicate(model, field, argument, path)
+                : emitScalarValue(model, field, argument, path);
+    }
+}
+function translateRelationPredicate(model, field, value, path) {
+    const advertised = field.capabilities.filter ?? [];
+    if (value === null) {
+        requireRelationFilter(advertised, "null", path);
+        assertEmission("null", path);
+        return null;
+    }
+    if (field.cardinality === "one") {
+        requireRelationFilter(advertised, "match", path);
+        assertEmission("match", path);
+        // §18.5: the nested predicate, unwrapped. No `is`.
+        return translateNode(model, field.target, value, path);
+    }
+    if (!isRecord(value)) {
+        throw new PrismaWhereTranslationError(`${path} must be an object of to-many predicates`);
+    }
+    const operand = {};
+    for (const [capability, argument] of Object.entries(value)) {
+        if (!isRelationFilterCapability(capability)) {
+            throw new PrismaWhereTranslationError(`${path}.${capability} is not an Aventara relation filter`);
+        }
+        const emission = RELATION_FILTER_EMISSIONS[capability];
+        if (emission.kind !== "key") {
+            throw new PrismaWhereTranslationError(`${path}.${capability} is not a to-many predicate`);
+        }
+        requireRelationFilter(advertised, capability, path);
+        operand[emission.token] = translateNode(model, field.target, argument, `${path}.${capability}`);
+    }
+    return operand;
+}
+/** The two capabilities whose emission is a shape rather than a key. */
+function assertEmission(capability, path) {
+    const emission = RELATION_FILTER_EMISSIONS[capability];
+    if (emission.kind === "key" || emission.kind === "edge-argument") {
+        throw new PrismaWhereTranslationError(`${path}: ${capability} has no inline emission`);
+    }
+}
+function requireOperator(advertised, operator, path) {
+    if (!advertised.includes(operator)) {
+        throw new PrismaWhereTranslationError(`${path}: "${operator}" is not advertised on this field, so the adapter will not emit it`);
+    }
+}
+function requireRelationFilter(advertised, capability, path) {
+    if (!advertised.includes(capability)) {
+        throw new PrismaWhereTranslationError(`${path}: "${capability}" is not advertised on this edge, so the adapter will not emit it`);
+    }
+}
+function isScalarFilterOperator(key) {
+    return Object.hasOwn(SCALAR_FILTER_EMISSIONS, key);
+}
+function isRelationFilterCapability(key) {
+    return Object.hasOwn(RELATION_FILTER_EMISSIONS, key);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Core's discriminant between a filter record and a VALUE, mirrored
+ * **[CORE, runtime/scalar-runtime.ts `isPlainRecord`]**: a class instance — a
+ * core `Decimal`, a `Date`, a `Uint8Array` — is a value, not a bag of operators.
+ */
+function isPlainRecord(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@aventara/prisma7-adapter",
+  "version": "0.1.0-pilot.0",
+  "license": "SEE LICENSE IN LICENSE",
+  "description": "The Prisma 7 adapter for Aventara.",
+  "type": "module",
+  "engines": {
+    "node": "^22.18.0 || >=24.2.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./generate": {
+      "types": "./dist/generate/index.d.ts",
+      "import": "./dist/generate/index.js",
+      "default": "./dist/generate/index.js"
+    }
+  },
+  "bin": {
+    "aventara-prisma7-generate": "./dist/generate/discovery.bin.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE-ADDITIONAL-PERMISSION.md"
+  ],
+  "dependencies": {
+    "@aventara/core": "0.1.0-pilot.0"
+  },
+  "peerDependencies": {
+    "@prisma/adapter-better-sqlite3": "^7.10.0",
+    "@prisma/adapter-pg": "^7.10.0",
+    "@prisma/client": "^7.10.0",
+    "prisma": "^7.10.0",
+    "typescript": ">=5.5.0 <7"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/adapter-better-sqlite3": {
+      "optional": true
+    },
+    "@prisma/adapter-pg": {
+      "optional": true
+    },
+    "prisma": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
+  "aventara": {
+    "adapter": {
+      "orm": "prisma",
+      "ormLabel": "Prisma",
+      "ormPackage": "@prisma/client",
+      "providers": [
+        "sqlite",
+        "postgresql"
+      ],
+      "drivers": {
+        "sqlite": "@prisma/adapter-better-sqlite3",
+        "postgresql": "@prisma/adapter-pg"
+      },
+      "generators": [
+        "prisma-client"
+      ],
+      "familyPackages": [
+        "prisma",
+        "@prisma/client",
+        "@prisma/prisma7",
+        "@prisma/orm-*"
+      ]
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@prisma/adapter-better-sqlite3": "7.10.0",
+    "@prisma/adapter-pg": "7.10.0",
+    "@prisma/client": "7.10.0",
+    "@prisma/prisma7": "7.10.0",
+    "@types/node": "24.10.1",
+    "prisma": "7.10.0",
+    "typescript": "^5.9.2",
+    "typescript-6": "npm:typescript@6.0.3"
+  },
+  "scripts": {
+    "build": "node node_modules/typescript/bin/tsc -p tsconfig.json",
+    "typecheck": "node node_modules/typescript/bin/tsc -p tsconfig.typecheck.json --noEmit",
+    "generate": "node node_modules/typescript/bin/tsc -p tsconfig.generate.json && node .generate/generate/discovery.generate.js && prisma generate --schema src/discovery/__fixtures__/ignore.prisma",
+    "db:push": "prisma db push --config prisma.config.sqlite.ts && sh -c 'if [ -n \"$AVENTARA_TEST_POSTGRES_URL\" ]; then prisma db push --config prisma.config.postgres.ts; else echo \"AVENTARA_TEST_POSTGRES_URL is unset: skipping the PostgreSQL schema push\"; fi'",
+    "test": "pnpm run generate && pnpm run db:push && vitest run --typecheck --typecheck.checker node_modules/typescript/bin/tsc --no-file-parallelism --config ../../vitest.config.mts --root .",
+    "test:sqlite": "pnpm run generate && prisma db push --config prisma.config.sqlite.ts && vitest run --config ../../vitest.config.mts --root . src/environment.spec.ts",
+    "test:postgres": "pnpm run generate && prisma db push --config prisma.config.postgres.ts && vitest run --config ../../vitest.config.mts --root . src/environment.spec.ts",
+    "lint": "biome lint src"
+  }
+}