@aventara/prisma7-adapter 0.1.0-pilot.0

package/dist/translation/mutation.translator.js

@@ -0,0 +1,580 @@
+import { advertisedDirectives, } from "@aventara/core";
+import { addressIdentifier } from "./identifier.addressing.js";
+import { emitScalarValue } from "./scalar.conversion.js";
+/**
+ * T-7's mutation half — one validated Aventara `data` in, one Prisma write
+ * argument out.
+ *
+ * # Pure, and the tables are the module
+ *
+ * No client, no database, no provider name. Three tables carry everything this
+ * module knows, each one TOTAL over a core union by `satisfies`, so a member
+ * added to core with no row here is a compile error rather than a silently
+ * dropped argument (C-855's emission half, C-837's translator table — the one
+ * `vocabulary.dictionary.ts` explicitly left to this task):
+ *
+ * - {@link SCALAR_DIRECTIVE_TOKENS} over `ScalarMutationDirective`;
+ * - {@link RELATION_DIRECTIVE_EMISSIONS} over `RelationMutationDirective`;
+ * - {@link MUTATION_DATA_SITES} over every standard operation key, which is
+ *   C-818's enforcement point.
+ *
+ * C-834's own table is NOT one of them any more: the scalar value conversion was
+ * born here, and `where.translator.ts` and `execution/result.shaper.ts` need the
+ * same answers, so it moved to `scalar.conversion.ts` and all three read it
+ * (Task 10's `identifier.addressing.ts` is the precedent). This module's
+ * emission site is {@link emitValue}, which is now a call rather than a copy.
+ *
+ * Phase 7's `RELATION_MUTATION_RECORD_SITES` is the pattern
+ * (`packages/core/src/runtime/mutation-planner.ts`): `as const satisfies
+ * Readonly<Record<Union, …>>` keeps every cell a literal while making the union
+ * coverage a compile-time obligation. Two of core's passes are already keyed
+ * that way; this is the third, and the only one that names Prisma.
+ *
+ * # Refusing is part of honouring (the `where.translator.ts` stance)
+ *
+ * The adapter assumes validated input (C-845). It still refuses to EMIT a
+ * directive the discovered model does not advertise for that field and stage,
+ * and refuses one for which Prisma's nested input at that stage and cardinality
+ * has no key at all. Both refusals are C-855 seen from the emission side: an
+ * argument is honoured or it is not sent. A directive quietly dropped here would
+ * surface as a write that silently did less than it was asked to.
+ *
+ * # C-818 cannot reach the Contract, so it is enforced here
+ *
+ * `RelationFieldCapabilities` is one record per field with a single `create`
+ * member **[CORE, adapters/adapter-field.ts]**, so "relation create directives
+ * for `create.one` and none for `create.many`" is unrepresentable in the model;
+ * `model.discoverer.ts` composes the permissive `create.one` answer and says so.
+ * The restriction therefore lives in {@link MUTATION_DATA_SITES}, which is keyed
+ * by the operation the data belongs to. Measured at 7.10.0 on both engines
+ * (2026-10-02), a nested relation key in a bulk write is a hard failure, not a
+ * no-op:
+ *
+ * - `post.createMany({ data: [{ title, author: { connect: … } }] })` →
+ *   *"Argument `authorId` is missing."*
+ * - `post.updateMany({ where, data: { category: { connect: … } } })` →
+ *   *"Unknown argument `category`. Available options are marked with ?."*
+ *
+ * # Nothing in the caller's arguments is touched
+ *
+ * Every object and array returned is new. The input is read, never written: a
+ * translator that mutated its argument would corrupt the second attempt of a
+ * retried operation, which is the one place the bug would not show up in a
+ * single-shot test.
+ */
+/** A mutation the model, the stage or the active operation does not license. */
+export class PrismaMutationTranslationError extends Error {
+    name = "PrismaMutationTranslationError";
+}
+/* ------------------------------------------------------------------ *
+ * C-837 — the scalar directive table                                  *
+ * ------------------------------------------------------------------ */
+/**
+ * The Prisma operand key for each of core's scalar mutation directives.
+ *
+ * The inverse of discovery's `PRISMA_SCALAR_DIRECTIVES` rename table, written
+ * here rather than imported from it for the reason `where.translator.ts` gives:
+ * that table is generate-time and `vocabulary.dictionary.ts` is excluded from
+ * the published build, while this module is runtime. `mutation.translator.spec.ts`
+ * round-trips every emitted token back through the dictionary, so the two cannot
+ * drift.
+ *
+ * Prisma's `set` has no row because it is not a directive: plain assignment is
+ * how core spells it, and the bare value is what this module emits — wrapping it
+ * in `{ set: … }` would add a token the request never carried.
+ */
+const SCALAR_DIRECTIVE_TOKENS = {
+    $increment: "increment",
+    $decrement: "decrement",
+    $multiply: "multiply",
+    $divide: "divide",
+    $push: "push",
+    $unset: "unset",
+};
+/**
+ * §18.5's normalization table, forward: one Aventara directive → one Prisma
+ * nested-write key and operand, per stage and cardinality.
+ *
+ * Total over `RelationMutationDirective`, so a ninth directive fails to compile
+ * — the same obligation core's two tables carry. Every cell below was read off
+ * the generated types and then RUN on both engines (2026-10-02); the three that
+ * matter are not key-for-key renames and would each have been wrong the obvious
+ * way.
+ *
+ * **To-many `$update` emits `updateMany`, not `update`.** Core validates a
+ * to-many `$update` entry's `where` with `validateWhere` — a GENERAL filter, not
+ * a unique selector **[CORE, operations/operation-validator-core.ts]** — and
+ * §18.5 says so in as many words: *"Prisma nested update/updateMany normalize to
+ * $update (general where → update every relation match)"*. Prisma's nested
+ * `update` takes `<T>UpdateWithWhereUnique…Input`, which refuses a general
+ * filter: *"Argument `where` of type PostWhereUniqueInput needs at least one of
+ * `id` arguments."* `updateMany` takes `{ where: <T>ScalarWhereInput, data }`,
+ * which is the shape core actually hands over.
+ *
+ * **To-many `$delete` emits `deleteMany`, for the same reason**, and its operand
+ * is the where UNWRAPPED: `deleteMany?: PostScalarWhereInput`. The singular
+ * `delete` is a `<T>WhereUniqueInput[]` and refuses the entry: *"Argument
+ * `delete`: Invalid value provided. Expected PostWhereUniqueInput[], provided
+ * Object."*
+ *
+ * **A `<T>ScalarWhereInput` carries scalars only**, so the two bulk forms refuse
+ * a relation predicate rather than emit one Prisma will reject: *"Unknown
+ * argument `category`. Did you mean `categoryId`?"* — and `updateMany`'s `data`
+ * is an `UpdateMany` input, so it admits no nested relation write either:
+ * *"Unknown argument `category`."*
+ *
+ * **The create stage admits four directives, not eight.**
+ * `<T>Create…NestedInput` carries `create`, `connectOrCreate`, `createMany` and
+ * `connect` and nothing else, on both cardinalities — *"Unknown argument
+ * `disconnect`. Did you mean `connect`?"*, *"Unknown argument `set`."* A to-one
+ * edge has no `set` at EITHER stage: *"Unknown argument `set`. Did you mean
+ * `upsert`?"* The `create: null` cells are therefore measured facts.
+ *
+ * They were also where discovery over-advertised: `PrismaRelationSurface` carried
+ * ONE mutation list, read off the UPDATE-stage nested input and reused for both
+ * stages, so the model offered `$set`/`$disconnect`/`$update`/`$delete`/`$upsert`
+ * at the create stage, which Prisma has no key for. This table refused them
+ * loudly — which is C-855's whole point — and the deriver now reads each stage
+ * from its own nested input (`createMutations` / `updateMutations`), so the
+ * Contract no longer advertises what these cells refuse.
+ */
+const RELATION_DIRECTIVE_EMISSIONS = {
+    $create: {
+        create: {
+            one: { key: "create", operand: "create-data" },
+            many: { key: "create", operand: "create-data" },
+        },
+        update: {
+            one: { key: "create", operand: "create-data" },
+            many: { key: "create", operand: "create-data" },
+        },
+    },
+    $connect: {
+        create: {
+            one: { key: "connect", operand: "unique" },
+            many: { key: "connect", operand: "unique" },
+        },
+        update: {
+            one: { key: "connect", operand: "unique" },
+            many: { key: "connect", operand: "unique" },
+        },
+    },
+    $connectOrCreate: {
+        create: {
+            one: { key: "connectOrCreate", operand: "connect-or-create" },
+            many: { key: "connectOrCreate", operand: "connect-or-create" },
+        },
+        update: {
+            one: { key: "connectOrCreate", operand: "connect-or-create" },
+            many: { key: "connectOrCreate", operand: "connect-or-create" },
+        },
+    },
+    $disconnect: {
+        create: { one: null, many: null },
+        update: {
+            one: { key: "disconnect", operand: "disconnect-true" },
+            many: { key: "disconnect", operand: "unique" },
+        },
+    },
+    $set: {
+        create: { one: null, many: null },
+        update: { one: null, many: { key: "set", operand: "unique" } },
+    },
+    $update: {
+        create: { one: null, many: null },
+        update: {
+            one: { key: "update", operand: "to-one-update" },
+            many: { key: "updateMany", operand: "to-many-update-many" },
+        },
+    },
+    $delete: {
+        create: { one: null, many: null },
+        update: {
+            one: { key: "delete", operand: "to-one-delete" },
+            many: { key: "deleteMany", operand: "to-many-delete-many" },
+        },
+    },
+    $upsert: {
+        create: { one: null, many: null },
+        update: {
+            one: { key: "upsert", operand: "to-one-upsert" },
+            many: { key: "upsert", operand: "to-many-upsert" },
+        },
+    },
+};
+/**
+ * Every standard operation, and the mutation data it carries — `null` for the
+ * ten that carry none.
+ *
+ * Total over the whole operation set rather than over the mutating subset, so a
+ * variant added to `ResourceOperations` fails to compile here instead of
+ * reaching the `forbidden`/`nested` question by default. The read and delete
+ * families are `null` for the same reason the dictionary spells a missing
+ * Aventara word `null`: *"no data"* is an answer, and an absent row is not.
+ *
+ * `create.many`, `create.count`, `update.many` and `update.count` are the
+ * `forbidden` four: they become `createMany`/`updateMany`, whose inputs carry
+ * scalars and foreign keys only. `update.first` is `nested` because the variant
+ * is emulated as a read followed by a singular `update` (T-7.1), and that write
+ * step is an `<M>UpdateInput`.
+ */
+const MUTATION_DATA_SITES = {
+    "find.first": null,
+    "find.unique": null,
+    "find.many": null,
+    "find.count": null,
+    "create.one": { stages: ["create"], relations: "nested" },
+    "create.many": { stages: ["create"], relations: "forbidden" },
+    "create.count": { stages: ["create"], relations: "forbidden" },
+    "update.first": { stages: ["update"], relations: "nested" },
+    "update.unique": { stages: ["update"], relations: "nested" },
+    "update.many": { stages: ["update"], relations: "forbidden" },
+    "update.count": { stages: ["update"], relations: "forbidden" },
+    "delete.first": null,
+    "delete.unique": null,
+    "delete.many": null,
+    "delete.count": null,
+    "upsert.unique": { stages: ["create", "update"], relations: "nested" },
+};
+/**
+ * Translates one validated Aventara mutation `data` into the Prisma write
+ * argument for the named operation and stage.
+ *
+ * @throws {PrismaMutationTranslationError} rather than emitting a directive the
+ * model does not advertise, one Prisma has no key for at this stage and
+ * cardinality, or a nested relation write inside a bulk argument (C-818).
+ */
+export function translateMutationData(input, dependencies) {
+    const key = `${input.operation.family}.${input.operation.variant}`;
+    if (!isOperationKey(key)) {
+        throw new PrismaMutationTranslationError(`data: "${key}" is not a standard Aventara operation`);
+    }
+    const site = MUTATION_DATA_SITES[key];
+    if (site === null) {
+        throw new PrismaMutationTranslationError(`data: "${key}" carries no mutation data`);
+    }
+    if (!site.stages.includes(input.stage)) {
+        throw new PrismaMutationTranslationError(`data: "${key}" carries no "${input.stage}" data`);
+    }
+    return translateRecord({
+        model: input.model,
+        dependencies,
+        relations: site.relations,
+    }, input.resource, input.data, input.stage, "data");
+}
+function translateRecord(pass, resourceKey, data, stage, path) {
+    const resource = pass.model.resources[resourceKey];
+    if (resource === undefined) {
+        throw new PrismaMutationTranslationError(`${path}: Resource "${resourceKey}" is not in the discovered model`);
+    }
+    if (!isRecord(data)) {
+        throw new PrismaMutationTranslationError(`${path} must be an object`);
+    }
+    const emitted = {};
+    for (const [key, value] of Object.entries(data)) {
+        const field = resource.fields[key];
+        if (field === undefined) {
+            throw new PrismaMutationTranslationError(`${path}.${key} is not a field of Resource "${resourceKey}"`);
+        }
+        if (field.kind === "scalar") {
+            emitted[key] = translateScalarWrite(pass, field, value, stage, `${path}.${key}`);
+            continue;
+        }
+        if (pass.relations === "forbidden") {
+            // C-818, and the only place it can be enforced: the Contract cannot say
+            // which variant this data belongs to.
+            throw new PrismaMutationTranslationError(`${path}.${key}: a bulk write carries no nested relation directive; Prisma's createMany/updateMany inputs admit scalars and foreign keys only (C-818)`);
+        }
+        emitted[key] = translateRelationWrite(pass, field, value, stage, `${path}.${key}`);
+    }
+    return emitted;
+}
+function translateScalarWrite(pass, field, value, stage, path) {
+    const advertised = field.capabilities[stage];
+    if (advertised === undefined) {
+        throw new PrismaMutationTranslationError(`${path} is not writable during ${stage}`);
+    }
+    const directives = directiveKeysOf(value, path);
+    if (directives === undefined) {
+        // Core's own rule: a value that is not a directive object IS plain
+        // assignment, and Prisma spells that the same way. Wrapping it in
+        // `{ set: … }` would emit a token the request never carried.
+        return emitValue(pass, field, value, path);
+    }
+    const operand = {};
+    for (const directive of directives) {
+        if (!isScalarMutationDirective(directive)) {
+            throw new PrismaMutationTranslationError(`${path}.${directive} is not an Aventara scalar mutation directive`);
+        }
+        if (!advertised.includes(directive)) {
+            throw new PrismaMutationTranslationError(`${path}: "${directive}" is not advertised on this field for ${stage}, so the adapter will not emit it`);
+        }
+        operand[SCALAR_DIRECTIVE_TOKENS[directive]] = emitValue(pass, field, value[directive], `${path}.${directive}`);
+    }
+    return operand;
+}
+/**
+ * The directive keys of a scalar write, or `undefined` when the value is a
+ * value.
+ *
+ * The discriminant is the `$` prefix, which is core's own
+ * (`validateScalarMutation` rejects a mixed object with `V1001` *"Scalar
+ * mutation action objects may contain only $-prefixed directive keys"*). It is
+ * mirrored rather than improved on: a `json` column's value is a plain object
+ * too, and any second discriminant would disagree with core's on some input.
+ */
+function directiveKeysOf(value, path) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const keys = Object.keys(value);
+    const directives = keys.filter((key) => key.startsWith("$"));
+    if (directives.length === 0) {
+        return undefined;
+    }
+    if (directives.length !== keys.length) {
+        throw new PrismaMutationTranslationError(`${path}: a scalar mutation action carries only $-prefixed directive keys`);
+    }
+    return directives;
+}
+/**
+ * C-834's emission site: one Aventara runtime value, one Prisma operand.
+ *
+ * The conversion itself belongs to `scalar.conversion.ts`, which owns both
+ * directions for every scalar; this module owns only *where* a value sits in a
+ * write argument.
+ */
+function emitValue(pass, field, value, path) {
+    return emitScalarValue(pass.model, field, value, path);
+}
+function translateRelationWrite(pass, field, value, stage, path) {
+    const advertised = advertisedDirectives(field.capabilities[stage]);
+    if (advertised === undefined) {
+        throw new PrismaMutationTranslationError(`${path} is not writable during ${stage}`);
+    }
+    if (!isRecord(value)) {
+        throw new PrismaMutationTranslationError(`${path} must be a directive object`);
+    }
+    const emitted = {};
+    for (const [directive, operand] of Object.entries(value)) {
+        if (!isRelationMutationDirective(directive)) {
+            throw new PrismaMutationTranslationError(`${path}.${directive} is not an Aventara relation mutation directive`);
+        }
+        if (!advertised.includes(directive)) {
+            throw new PrismaMutationTranslationError(`${path}: "${directive}" is not advertised on this edge for ${stage}, so the adapter will not emit it`);
+        }
+        const emission = RELATION_DIRECTIVE_EMISSIONS[directive][stage][field.cardinality];
+        if (emission === null) {
+            throw new PrismaMutationTranslationError(`${path}: Prisma's nested ${stage} input for a to-${field.cardinality} edge has no operand for "${directive}", so the adapter will not emit one`);
+        }
+        if (emission.key in emitted) {
+            throw new PrismaMutationTranslationError(`${path}.${directive} would overwrite the "${emission.key}" operand another directive already emitted`);
+        }
+        emitted[emission.key] = emitRelationOperand(pass, field.target, field.cardinality, emission.operand, operand, `${path}.${directive}`);
+    }
+    return emitted;
+}
+/**
+ * One directive's operand, with its ARITY preserved: core admits a single entry
+ * or an array on a to-many edge, Prisma admits both, and collapsing or
+ * expanding one would change the shape the request carried.
+ */
+function emitRelationOperand(pass, target, cardinality, form, operand, path) {
+    if (cardinality === "many" && Array.isArray(operand)) {
+        return operand.map((entry, index) => emitRelationEntry(pass, target, form, entry, `${path}[${index}]`));
+    }
+    return emitRelationEntry(pass, target, form, operand, path);
+}
+function emitRelationEntry(pass, target, form, entry, path) {
+    switch (form) {
+        case "create-data":
+            return translateRecord(nested(pass), target, entry, "create", path);
+        case "unique":
+            return addressUnique(pass, target, entry, path);
+        case "connect-or-create": {
+            const { where, create } = requireMembers(entry, ["where", "create"], path);
+            return {
+                where: addressUnique(pass, target, where, `${path}.where`),
+                create: translateRecord(nested(pass), target, create, "create", `${path}.create`),
+            };
+        }
+        case "disconnect-true":
+            if (entry !== true) {
+                throw new PrismaMutationTranslationError(`${path}: a to-one $disconnect is true`);
+            }
+            return true;
+        case "to-one-update": {
+            const { data } = requireMembers(entry, ["data"], path);
+            return {
+                ...optionalWhere(pass, target, entry, path),
+                data: translateRecord(nested(pass), target, data, "update", `${path}.data`),
+            };
+        }
+        case "to-one-delete": {
+            if (entry === true) {
+                return true;
+            }
+            if (!isRecord(entry)) {
+                throw new PrismaMutationTranslationError(`${path}: a to-one $delete is true or an optional where object`);
+            }
+            if (!Object.hasOwn(entry, "where")) {
+                // `{}` is "delete the related row", which Prisma spells `true`. The
+                // empty object is not a Prisma where: `delete: {}` would match nothing.
+                return true;
+            }
+            return pass.dependencies.translateWhere(target, entry.where, `${path}.where`);
+        }
+        case "to-one-upsert": {
+            const { create, update } = requireMembers(entry, ["create", "update"], path);
+            return {
+                ...optionalWhere(pass, target, entry, path),
+                create: translateRecord(nested(pass), target, create, "create", `${path}.create`),
+                update: translateRecord(nested(pass), target, update, "update", `${path}.update`),
+            };
+        }
+        case "to-many-update-many": {
+            const { where, data } = requireMembers(entry, ["where", "data"], path);
+            return {
+                where: scalarWhere(pass, target, where, `${path}.where`),
+                // `<T>UpdateManyWithWhere…Input.data` is an UpdateMany input: scalars
+                // and foreign keys only, exactly as a top-level `updateMany`.
+                data: translateRecord(bulk(pass), target, data, "update", `${path}.data`),
+            };
+        }
+        case "to-many-delete-many": {
+            const { where } = requireMembers(entry, ["where"], path);
+            // `deleteMany` takes the scalar where itself, not `{ where }`.
+            return scalarWhere(pass, target, where, `${path}.where`);
+        }
+        case "to-many-upsert": {
+            const { where, create, update } = requireMembers(entry, ["where", "create", "update"], path);
+            return {
+                where: addressUnique(pass, target, where, `${path}.where`),
+                create: translateRecord(nested(pass), target, create, "create", `${path}.create`),
+                update: translateRecord(nested(pass), target, update, "update", `${path}.update`),
+            };
+        }
+    }
+}
+function nested(pass) {
+    return pass.relations === "nested" ? pass : { ...pass, relations: "nested" };
+}
+function bulk(pass) {
+    return pass.relations === "forbidden"
+        ? pass
+        : { ...pass, relations: "forbidden" };
+}
+/** A to-one `$update`/`$upsert` `where` is optional, and absent is not `undefined`. */
+function optionalWhere(pass, target, entry, path) {
+    if (!isRecord(entry) || !Object.hasOwn(entry, "where")) {
+        return {};
+    }
+    // Prisma's to-one `update`/`upsert` `where` is a general `<T>WhereInput`, so
+    // core's flat unique selector needs no addressing here — it is already a valid
+    // filter. Measured on both engines (2026-10-02).
+    return {
+        where: pass.dependencies.translateWhere(target, entry.where, `${path}.where`),
+    };
+}
+/**
+ * A `<T>ScalarWhereInput`: the nested bulk forms' filter, which carries scalar
+ * columns only.
+ *
+ * Core's `validateWhere` admits a relation predicate here, so this is a real
+ * narrowing and it refuses rather than emits: Prisma answers *"Unknown argument
+ * `category`. Did you mean `categoryId`?"* on both engines. Reported as a
+ * C-855 gap in the advertised surface rather than silently dropped.
+ */
+function scalarWhere(pass, target, where, path) {
+    requireScalarPredicate(pass, target, where, path);
+    return pass.dependencies.translateWhere(target, where, path);
+}
+function requireScalarPredicate(pass, target, where, path) {
+    if (Array.isArray(where)) {
+        for (const [index, member] of where.entries()) {
+            requireScalarPredicate(pass, target, member, `${path}[${index}]`);
+        }
+        return;
+    }
+    if (!isRecord(where)) {
+        return;
+    }
+    const resource = pass.model.resources[target];
+    if (resource === undefined) {
+        throw new PrismaMutationTranslationError(`${path}: Resource "${target}" is not in the discovered model`);
+    }
+    for (const [key, value] of Object.entries(where)) {
+        if (key === "AND" || key === "OR" || key === "NOT") {
+            requireScalarPredicate(pass, target, value, `${path}.${key}`);
+            continue;
+        }
+        if (resource.fields[key]?.kind === "relation") {
+            throw new PrismaMutationTranslationError(`${path}.${key}: a nested bulk write filters on scalar fields only, so the adapter will not emit a relation predicate`);
+        }
+    }
+}
+/**
+ * Core's FLAT unique selector → Prisma's `<T>WhereUniqueInput`, for a NESTED
+ * `connect`/`disconnect`/`set`/`update`/`upsert` target.
+ *
+ * The addressing rule itself lives in `identifier.addressing.ts`, which Task 10
+ * extracted when the top-level where-unique made it the third copy. What stays
+ * here is this site's two decisions: the match is **exact**, and each member's
+ * value goes out through C-834's scalar emission (`scalar.conversion.ts`).
+ */
+function addressUnique(pass, target, selector, path) {
+    if (!isRecord(selector)) {
+        throw new PrismaMutationTranslationError(`${path} must be a unique identifier object`);
+    }
+    const resource = pass.model.resources[target];
+    if (resource === undefined) {
+        throw new PrismaMutationTranslationError(`${path}: Resource "${target}" is not in the discovered model`);
+    }
+    const addresses = pass.dependencies.identifiers[target];
+    if (addresses === undefined) {
+        throw new PrismaMutationTranslationError(`${path}: Resource "${target}" has no Prisma addressing in the translation table`);
+    }
+    // `"exact"`: core's unique selector carries one identifier and nothing else,
+    // so a spare key means it is not that identifier. Each member goes out through
+    // C-834's scalar emission, which is why the conversion is passed in rather
+    // than the table imported by the addressing module.
+    const addressed = addressIdentifier({
+        addresses,
+        values: selector,
+        match: "exact",
+        emit: (member, value) => emitSelectorMember(pass, resource.fields[member], value, `${path}.${member}`),
+    });
+    if (addressed === undefined) {
+        throw new PrismaMutationTranslationError(`${path}: { ${Object.keys(selector).join(", ")} } is no identifier of Resource "${target}", so it addresses no row`);
+    }
+    return addressed.where;
+}
+function emitSelectorMember(pass, field, value, path) {
+    if (field === undefined || field.kind !== "scalar") {
+        throw new PrismaMutationTranslationError(`${path} is not a scalar field of the target Resource`);
+    }
+    return emitValue(pass, field, value, path);
+}
+function requireMembers(entry, members, path) {
+    if (!isRecord(entry)) {
+        throw new PrismaMutationTranslationError(`${path} must be an object carrying ${members.join(" and ")}`);
+    }
+    for (const member of members) {
+        if (!Object.hasOwn(entry, member)) {
+            throw new PrismaMutationTranslationError(`${path}.${member} is required by this directive`);
+        }
+    }
+    return entry;
+}
+function isOperationKey(key) {
+    return Object.hasOwn(MUTATION_DATA_SITES, key);
+}
+function isScalarMutationDirective(key) {
+    return Object.hasOwn(SCALAR_DIRECTIVE_TOKENS, key);
+}
+function isRelationMutationDirective(key) {
+    return Object.hasOwn(RELATION_DIRECTIVE_EMISSIONS, key);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}