@aventara/prisma7-adapter 0.1.0-pilot.0

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

@@ -0,0 +1,273 @@
+import type { AdapterModel, AdapterOperation } from "@aventara/core";
+import type { PrismaResourceTranslation } from "../discovery/discovery-artifact.interface.js";
+import { type PrismaProjectionPlan } from "./projection.translator.js";
+/**
+ * T-7 — **one validated Aventara operation → one provider call description**,
+ * and the module that makes the whole sixteen-variant grammar assertable as pure
+ * data with no database in sight.
+ *
+ * Splitting translation from execution is the plan's single largest testability
+ * decision (T-7): everything below is a pure function of the discovered model,
+ * the generate-time translation table and the arguments core validated. The
+ * database is needed only for the *other* half, `execution/operation.executor.ts`.
+ *
+ * # The dispatch table is the module
+ *
+ * {@link PRISMA_VARIANT_DISPATCH} is total over core's own sixteen
+ * `family.variant` keys by `satisfies`, so a seventeenth standard operation added
+ * to core is a compile error here rather than a variant that quietly reaches no
+ * provider call. Reading it answers, in one place, every question of the form
+ * "what does Aventara's X actually issue".
+ *
+ * # The negative half of the table is the load-bearing half
+ *
+ * {@link PrismaAction} deliberately **excludes** `findUniqueOrThrow` and
+ * `findFirstOrThrow` (RC-2: core's outcome mapper owns the absence decision, and
+ * an `OrThrow` call would move it into the adapter), `groupBy` and `aggregate`
+ * (spec §18.5), and **every raw action** — the `findRaw`/`aggregateRaw` model
+ * actions and the client's own raw methods — which C-853 forbids outright and
+ * permanently. Aventara is not an ORM and reaches the database only through the
+ * adapter's ORM; a raw statement would forfeit the ORM's own injection
+ * protection and oblige Aventara to build its own. Because the exclusion lives in
+ * the *type*, a raw call is not representable in a {@link PrismaExecutionPlan} at
+ * all: the rule is enforced by the compiler, not by a reviewer's memory.
+ * `operation.translator.spec.ts` asserts the same thing from the value side, as
+ * the belt to that type's braces.
+ *
+ * # `delete.many` is a hole in the table, and the hole is the decision
+ *
+ * 7.10.0 has no `deleteManyAndReturn` **[PKG]**, and the architect ruled the
+ * variant **omitted rather than emulated** (C-829, D-826). `operations.deriver.ts`
+ * therefore never advertises it, so core rejects the request with `A2002
+ * UNKNOWN_OPERATION` before any adapter call. The table still carries the key —
+ * it is total over core's grammar — with an `"unavailable"` entry, so the
+ * omission is a fact a reader can find rather than an absence they have to infer.
+ *
+ * # First-style variants, and the write route
+ *
+ * `update.first` and `delete.first` are **framework-manufactured** (D-828): a
+ * cross-ORM survey found the four-part shape — general filter, ordering decides
+ * "first", effect limited to one row, the affected row is returned, all in one
+ * call — essentially absent across ORM design, and Prisma 7.10.0 has no
+ * `updateFirst`/`deleteFirst` **[PKG]**. So the plan is an ordinary read then
+ * write, and its two steps are {@link PrismaExecutionPlan}'s `"emulated"` arm.
+ *
+ * **The write route is Route A — select-first + unique mutation — and Task 10
+ * measured it rather than inheriting it.** T-7.1.1 recorded two routes and §14e
+ * reserved the choice; §1.0 forbids an implementation task from blocking on an
+ * owner decision, so Task 10 ran both against the real 7.10.0 client on **both**
+ * engines. Every row came out for Route A, and two of them came out *against*
+ * Route B:
+ *
+ * ```text
+ * measured 2026-10-02, @prisma/client 7.10.0, SQLite + PostgreSQL 18, identical
+ *
+ * A  update({ where: { id, AND: […] }, data, select })          -> returned the row
+ * A  …with a non-matching AND                                   -> threw P2025, row untouched
+ * A  …select reaching a to-many relation AND _count             -> returned both
+ * A  delete({ where: { id, AND: […] }, select })                -> returned the deleted row
+ * A  …with a non-matching AND                                   -> threw P2025, row still present
+ * A  findFirst + update inside $transaction, non-matching AND   -> threw P2025 at the emulator's own call site
+ * B  updateManyAndReturn({ where: { id, AND: […] }, … })        -> returned [row]
+ * B  …with a non-matching AND                                   -> resolved []
+ * B  …select: { posts: { … } }                                  -> REJECTED: "Unknown field `posts` for select
+ *                                                                  statement on model `UpdateManyAuthorAndReturnOutputType`"
+ * B  …select: { _count: { … } }                                 -> REJECTED: same, for `_count`
+ * B  deleteMany({ where: { id, AND: […] } })                    -> { count: 1 } — carries no row at all
+ * ```
+ *
+ * So Route A is the mechanism spec §8.3's own worked example names, it satisfies
+ * §8.2's return contract for **every** projection core can plan, and it needs no
+ * pre-write projection read and no identifier strip. Route B cannot serve a
+ * caller projection that reaches a to-many relation or `$count` at all, and its
+ * `delete.first` must read before it writes. The route is **one entry** in the
+ * table below — {@link FIRST_VARIANT_WRITE_ROUTE} — which is the seam D-801/§9
+ * put here precisely so §14e's ratification (or reversal) is one edit.
+ *
+ * # The write step of an emulated plan is a template, and says so
+ *
+ * A `"single"` plan's call is issuable as written. An `"emulated"` plan's write
+ * step is **not**, by construction: its `where` carries the caller's re-asserted
+ * predicate under `AND` and the identifier is added by
+ * `execution/first-variant.emulator.ts` from the row the read returned. That is
+ * what "emulated" means — the second statement is not knowable until the first
+ * has run — and it is why the emulator, not this module, issues it.
+ *
+ * # Nothing is emitted that the framework did not send (C-855, D-830)
+ *
+ * Every key below is added only when the corresponding Aventara argument is
+ * **present**. An absent argument and an `undefined` one are different arguments
+ * to a provider, so `"take" in args` is never made true by accident. An argument
+ * this module does not recognise raises rather than being dropped: an argument
+ * that typechecks and is silently ignored is worse than an absent one, because
+ * the absent one fails loudly at the caller (D-830's MikroORM evidence).
+ */
+/** The `ModelAction` subset this adapter uses. See the header for the exclusions. */
+export type PrismaAction = "findUnique" | "findFirst" | "findMany" | "count" | "create" | "createMany" | "createManyAndReturn" | "update" | "updateMany" | "updateManyAndReturn" | "delete" | "deleteMany" | "upsert";
+/** One provider call description, as plain data. */
+export type PrismaCall = {
+    /**
+     * The Prisma **model** name. Discovery's existence gate keys a Resource on the
+     * PSL model name, so the Resource key *is* the model name; the delegate
+     * property that reaches it is the executor's concern, not translation's.
+     */
+    readonly model: string;
+    readonly action: PrismaAction;
+    readonly args: Readonly<Record<string, unknown>>;
+};
+/** A variant is either one call, or an emulated sequence (§8.3, D-807). */
+export type PrismaExecutionPlan = {
+    readonly kind: "single";
+    readonly call: PrismaCall;
+} | {
+    readonly kind: "emulated";
+    readonly steps: readonly PrismaCall[];
+    readonly atomicity: "outer-tx" | "own-tx";
+};
+/**
+ * What the variant owes its caller, and therefore which shaper runs (T-8).
+ *
+ * It is a property of the *variant*, not of the provider answer, so it belongs
+ * in the dispatch table beside the action rather than in a second table the
+ * executor would have to keep in step.
+ */
+export type PrismaResultKind = "row" | "rows" | "count";
+export type PrismaVariantDispatch = {
+    readonly kind: "single";
+    readonly action: PrismaAction;
+    readonly result: PrismaResultKind;
+} | {
+    readonly kind: "emulated";
+    readonly read: PrismaAction;
+    readonly write: PrismaAction;
+    readonly result: PrismaResultKind;
+} | {
+    readonly kind: "unavailable";
+    readonly reason: string;
+};
+/** The sixteen-variant dispatch table (T-7, §18.4), total over core's grammar. */
+export declare const PRISMA_VARIANT_DISPATCH: {
+    readonly "find.first": {
+        readonly kind: "single";
+        readonly action: "findFirst";
+        readonly result: "row";
+    };
+    readonly "find.unique": {
+        readonly kind: "single";
+        readonly action: "findUnique";
+        readonly result: "row";
+    };
+    readonly "find.many": {
+        readonly kind: "single";
+        readonly action: "findMany";
+        readonly result: "rows";
+    };
+    readonly "find.count": {
+        readonly kind: "single";
+        readonly action: "count";
+        readonly result: "count";
+    };
+    readonly "create.one": {
+        readonly kind: "single";
+        readonly action: "create";
+        readonly result: "row";
+    };
+    readonly "create.many": {
+        readonly kind: "single";
+        readonly action: "createManyAndReturn";
+        readonly result: "rows";
+    };
+    readonly "create.count": {
+        readonly kind: "single";
+        readonly action: "createMany";
+        readonly result: "count";
+    };
+    readonly "update.first": {
+        readonly kind: "emulated";
+        readonly read: "findFirst";
+        readonly write: "update";
+        readonly result: "row";
+    };
+    readonly "update.unique": {
+        readonly kind: "single";
+        readonly action: "update";
+        readonly result: "row";
+    };
+    readonly "update.many": {
+        readonly kind: "single";
+        readonly action: "updateManyAndReturn";
+        readonly result: "rows";
+    };
+    readonly "update.count": {
+        readonly kind: "single";
+        readonly action: "updateMany";
+        readonly result: "count";
+    };
+    readonly "delete.first": {
+        readonly kind: "emulated";
+        readonly read: "findFirst";
+        readonly write: "delete";
+        readonly result: "row";
+    };
+    readonly "delete.unique": {
+        readonly kind: "single";
+        readonly action: "delete";
+        readonly result: "row";
+    };
+    readonly "delete.many": {
+        readonly kind: "unavailable";
+        readonly reason: "@prisma/client 7.10.0 has no deleteManyAndReturn, so delete.many is omitted rather than emulated (C-829, D-826); delete.count deletes a filtered set";
+    };
+    readonly "delete.count": {
+        readonly kind: "single";
+        readonly action: "deleteMany";
+        readonly result: "count";
+    };
+    readonly "upsert.unique": {
+        readonly kind: "single";
+        readonly action: "upsert";
+        readonly result: "row";
+    };
+};
+/** An operation the adapter will not translate. */
+export declare class PrismaOperationTranslationError extends Error {
+    readonly name = "PrismaOperationTranslationError";
+}
+/**
+ * The translation of one operation: the plan, plus the projection plan the result
+ * shaper needs.
+ *
+ * T-7 names only `PrismaExecutionPlan`, and that is not enough on its own:
+ * `AdapterOperation` carries no read plan **[CORE]**, so Task 8's
+ * {@link PrismaProjectionPlan} — the reconstruction of where every `$count`
+ * envelope sits — is produced *here*, while translating the projection, and
+ * cannot be recovered from the emitted Prisma arguments afterwards (Prisma's
+ * `_count` is a sibling key, not a position). Returning it beside the plan is
+ * what keeps `result.shaper.ts` free of a second, drifting reconstruction.
+ */
+export type PrismaOperationTranslation = {
+    readonly plan: PrismaExecutionPlan;
+    readonly projection: PrismaProjectionPlan;
+    /**
+     * The caller's `where`, translated, or `undefined` when they sent none.
+     *
+     * Recorded for the emulator, which re-asserts it on the write (C-856, D-829).
+     * It is the same value the read step carries, by identity, so the two halves
+     * of the manufacture cannot assert different predicates.
+     */
+    readonly predicate: Readonly<Record<string, unknown>> | undefined;
+};
+export type PrismaOperationTranslationInput = {
+    readonly model: AdapterModel;
+    /** The generate-time translation table: Prisma addressing per Resource. */
+    readonly translation: Readonly<Record<string, PrismaResourceTranslation>>;
+    readonly operation: AdapterOperation;
+};
+/**
+ * Translates one validated Aventara operation.
+ *
+ * @throws {PrismaOperationTranslationError} for a variant the adapter advertises
+ * no call for, an argument it does not recognise, or a unique selector that
+ * addresses no row — never a silently narrowed or widened call.
+ */
+export declare function translateOperation(input: PrismaOperationTranslationInput): PrismaOperationTranslation;

package/dist/translation/operation.translator.js

@@ -0,0 +1,377 @@
+import { addressIdentifier } from "./identifier.addressing.js";
+import { translateMutationData } from "./mutation.translator.js";
+import { translateOrderBy, translatePagination, } from "./order-pagination.translator.js";
+import { translateProjection, } from "./projection.translator.js";
+import { translateWhere } from "./where.translator.js";
+/**
+ * The chosen first-variant write route, in one place (§14e, T-7.1.1).
+ *
+ * Route A: the read selects the identifier, and the write is Prisma's own
+ * `update`/`delete` narrowed to that identifier with the caller's predicate
+ * re-asserted. Both are projection-carrying — their result maps through
+ * `GetFindResult`, the same helper `findFirst` uses **[PKG,
+ * `runtime/client.d.ts:1352`, `:1356`, `:1144`]** — and Task 10 measured both on
+ * both engines (see the header). Switching to Route B is an edit to these two
+ * cells and to `first-variant.emulator.ts`'s lost-row detection, and nothing else.
+ */
+const FIRST_VARIANT_WRITE_ROUTE = {
+    update: "update",
+    delete: "delete",
+};
+/** The sixteen-variant dispatch table (T-7, §18.4), total over core's grammar. */
+export const PRISMA_VARIANT_DISPATCH = {
+    "find.first": { kind: "single", action: "findFirst", result: "row" },
+    // RC-2: `findUnique` and a returned `null`, never `findUniqueOrThrow` — core's
+    // `OUTCOME_TABLE` owns the absence decision and maps the `null` to `A2003`.
+    "find.unique": { kind: "single", action: "findUnique", result: "row" },
+    "find.many": { kind: "single", action: "findMany", result: "rows" },
+    "find.count": { kind: "single", action: "count", result: "count" },
+    "create.one": { kind: "single", action: "create", result: "row" },
+    // C-817: the row-returning bulk write is what `create.many` owes its caller;
+    // `createMany` answers `{ count }` and is `create.count`'s call instead.
+    "create.many": {
+        kind: "single",
+        action: "createManyAndReturn",
+        result: "rows",
+    },
+    "create.count": { kind: "single", action: "createMany", result: "count" },
+    "update.first": {
+        kind: "emulated",
+        read: "findFirst",
+        write: FIRST_VARIANT_WRITE_ROUTE.update,
+        result: "row",
+    },
+    "update.unique": { kind: "single", action: "update", result: "row" },
+    "update.many": {
+        kind: "single",
+        action: "updateManyAndReturn",
+        result: "rows",
+    },
+    "update.count": { kind: "single", action: "updateMany", result: "count" },
+    "delete.first": {
+        kind: "emulated",
+        read: "findFirst",
+        write: FIRST_VARIANT_WRITE_ROUTE.delete,
+        result: "row",
+    },
+    "delete.unique": { kind: "single", action: "delete", result: "row" },
+    "delete.many": {
+        kind: "unavailable",
+        reason: "@prisma/client 7.10.0 has no deleteManyAndReturn, so delete.many is omitted rather than emulated (C-829, D-826); delete.count deletes a filtered set",
+    },
+    "delete.count": { kind: "single", action: "deleteMany", result: "count" },
+    "upsert.unique": { kind: "single", action: "upsert", result: "row" },
+};
+/** An operation the adapter will not translate. */
+export class PrismaOperationTranslationError extends Error {
+    name = "PrismaOperationTranslationError";
+}
+/**
+ * Translates one validated Aventara operation.
+ *
+ * @throws {PrismaOperationTranslationError} for a variant the adapter advertises
+ * no call for, an argument it does not recognise, or a unique selector that
+ * addresses no row — never a silently narrowed or widened call.
+ */
+export function translateOperation(input) {
+    const key = `${input.operation.family}.${input.operation.variant}`;
+    const dispatch = Object.hasOwn(PRISMA_VARIANT_DISPATCH, key)
+        ? PRISMA_VARIANT_DISPATCH[key]
+        : undefined;
+    if (dispatch === undefined) {
+        throw new PrismaOperationTranslationError(`"${key}" is not a standard Aventara operation`);
+    }
+    if (dispatch.kind === "unavailable") {
+        throw new PrismaOperationTranslationError(`"${key}" is not available on the Prisma adapter: ${dispatch.reason}`);
+    }
+    const context = {
+        model: input.model,
+        translation: input.translation,
+        operation: input.operation,
+        resource: input.operation.resource,
+        args: input.operation.arguments,
+    };
+    const projection = translateProjection(context.args, {
+        translateRelationArguments: relationArgumentTranslator(context),
+    });
+    const predicate = context.args.where === undefined || isUniqueSelectorVariant(key)
+        ? undefined
+        : translateWhere({
+            model: context.model,
+            resource: context.resource,
+            where: context.args.where,
+        });
+    if (dispatch.kind === "single") {
+        return {
+            plan: {
+                kind: "single",
+                call: {
+                    model: context.resource,
+                    action: dispatch.action,
+                    args: singleCallArguments(context, key, predicate, projection.args),
+                },
+            },
+            projection: projection.plan,
+            predicate,
+        };
+    }
+    return {
+        plan: {
+            kind: "emulated",
+            steps: [
+                {
+                    model: context.resource,
+                    action: dispatch.read,
+                    args: {
+                        ...(predicate === undefined ? {} : { where: predicate }),
+                        ...orderByArgument(context),
+                        // The read selects the identifier and nothing else: under Route A
+                        // the WRITE carries the caller's projection, so reading it twice
+                        // would be a statement the contract does not need.
+                        select: identifierSelect(context),
+                    },
+                },
+                {
+                    model: context.resource,
+                    action: dispatch.write,
+                    args: {
+                        // A template: the identifier is added by the emulator from the row
+                        // the read returned. `AND` carries the re-assertion (C-856, D-829).
+                        ...(predicate === undefined ? {} : { where: { AND: predicate } }),
+                        ...(context.operation.family === "update"
+                            ? { data: mutationData(context, "update", "data") }
+                            : {}),
+                        ...projection.args,
+                    },
+                },
+            ],
+            atomicity: "own-tx",
+        },
+        projection: projection.plan,
+        predicate,
+    };
+}
+/**
+ * The four variants whose `where` is core's FLAT unique selector rather than a
+ * general predicate, read from core's own rule: `hasGeneralRootWhere` is false
+ * for exactly `find.unique`, `update.unique`, `delete.unique` and `upsert.unique`
+ * **[CORE, operations/operation-validator.ts]**.
+ */
+function isUniqueSelectorVariant(key) {
+    return (key === "find.unique" ||
+        key === "update.unique" ||
+        key === "delete.unique" ||
+        key === "upsert.unique");
+}
+function singleCallArguments(context, key, predicate, projectionArgs) {
+    const unique = isUniqueSelectorVariant(key);
+    const where = unique
+        ? { where: uniqueWhere(context) }
+        : predicate === undefined
+            ? {}
+            : { where: predicate };
+    switch (key) {
+        case "find.first":
+            return { ...where, ...orderByArgument(context), ...projectionArgs };
+        case "find.unique":
+            return { ...where, ...projectionArgs };
+        case "find.many":
+            return {
+                ...where,
+                ...orderByArgument(context),
+                ...paginationArguments(context),
+                ...projectionArgs,
+            };
+        case "find.count":
+        case "delete.count":
+            return where;
+        case "create.one":
+            return {
+                data: mutationData(context, "create", "data"),
+                ...projectionArgs,
+            };
+        case "create.many":
+            return {
+                data: bulkMutationData(context, key, "create"),
+                ...projectionArgs,
+            };
+        case "create.count":
+            return { data: bulkMutationData(context, key, "create") };
+        case "update.unique":
+            return {
+                ...where,
+                data: mutationData(context, "update", "data"),
+                ...projectionArgs,
+            };
+        case "update.many":
+            return {
+                ...where,
+                data: mutationData(context, "update", "data"),
+                ...projectionArgs,
+            };
+        case "update.count":
+            return { ...where, data: mutationData(context, "update", "data") };
+        case "delete.unique":
+            return { ...where, ...projectionArgs };
+        case "upsert.unique":
+            return {
+                ...where,
+                create: mutationData(context, "create", "create"),
+                update: mutationData(context, "update", "update"),
+                ...projectionArgs,
+            };
+        default:
+            throw new PrismaOperationTranslationError(`"${key}" has a dispatch entry and no argument shape, which is a translator defect`);
+    }
+}
+/** Core's flat unique selector → `<M>WhereUniqueInput`, at the top level. */
+function uniqueWhere(context) {
+    const selector = context.args.where;
+    if (!isRecord(selector)) {
+        throw new PrismaOperationTranslationError("where must be a unique identifier object for a unique variant");
+    }
+    const addressed = addressIdentifier({
+        addresses: identifiersOf(context, context.resource),
+        values: selector,
+        match: "exact",
+        // A unique selector's values are scalars core has already normalized. The
+        // one conversion C-834 names — a core `Decimal`, which Prisma refuses — is
+        // NOT applied here, and that is a recorded gap rather than an omission: see
+        // `operation.executor.ts`'s header.
+        emit: (_member, value) => value,
+    });
+    if (addressed === undefined) {
+        throw new PrismaOperationTranslationError(`where: { ${Object.keys(selector).join(", ")} } is no identifier of Resource "${context.resource}", so it addresses no row`);
+    }
+    return addressed.where;
+}
+/** The identifier the first-style read selects: the first recorded criterion. */
+function identifierSelect(context) {
+    const [address] = identifiersOf(context, context.resource);
+    if (address === undefined) {
+        throw new PrismaOperationTranslationError(`Resource "${context.resource}" has no identifier, so a first-style variant has nothing to write by`);
+    }
+    return Object.fromEntries(address.members.map((member) => [member, true]));
+}
+function identifiersOf(context, resource) {
+    const entry = context.translation[resource];
+    if (entry === undefined) {
+        throw new PrismaOperationTranslationError(`Resource "${resource}" has no Prisma addressing in the translation table`);
+    }
+    return entry.identifierKeys;
+}
+function orderByArgument(context) {
+    if (context.args.orderBy === undefined) {
+        return {};
+    }
+    return {
+        orderBy: translateOrderBy({
+            model: context.model,
+            resource: context.resource,
+            orderBy: context.args.orderBy,
+        }),
+    };
+}
+function paginationArguments(context) {
+    return translatePagination({
+        ...(typeof context.args.limit === "number"
+            ? { limit: context.args.limit }
+            : {}),
+        ...(typeof context.args.offset === "number"
+            ? { offset: context.args.offset }
+            : {}),
+        ...(isRecord(context.args.cursor) ? { cursor: context.args.cursor } : {}),
+        identifiers: identifiersOf(context, context.resource),
+    });
+}
+function mutationData(context, stage, argument) {
+    return translateMutationData({
+        model: context.model,
+        resource: context.resource,
+        operation: context.operation,
+        stage,
+        data: context.args[argument],
+    }, mutationDependencies(context));
+}
+/** `create.many`/`create.count` carry an ARRAY of records **[CORE]**. */
+function bulkMutationData(context, key, stage) {
+    const data = context.args.data;
+    if (!Array.isArray(data)) {
+        throw new PrismaOperationTranslationError(`"${key}" carries an array of records in \`data\``);
+    }
+    const dependencies = mutationDependencies(context);
+    return data.map((entry) => translateMutationData({
+        model: context.model,
+        resource: context.resource,
+        operation: context.operation,
+        stage,
+        data: entry,
+    }, dependencies));
+}
+function mutationDependencies(context) {
+    return {
+        translateWhere: (resource, where) => translateWhere({ model: context.model, resource, where }),
+        identifiers: Object.fromEntries(Object.entries(context.translation).map(([resource, entry]) => [
+            resource,
+            entry.identifierKeys,
+        ])),
+    };
+}
+/**
+ * Task 7's vocabulary, as the projection translator's one dependency.
+ *
+ * The nested arguments are translated against the **target** Resource, which the
+ * projection path names: `projection.translator.ts` owns where a relation sits
+ * and this closure owns what its arguments mean, which is the seam that keeps the
+ * `_count` filter the *same* translated `where` the relation read uses.
+ */
+function relationArgumentTranslator(context) {
+    return (args, { path }) => {
+        const target = resolveRelationTarget(context, path);
+        const emitted = {};
+        for (const key of Object.keys(args)) {
+            if (key !== "where" &&
+                key !== "orderBy" &&
+                key !== "limit" &&
+                key !== "offset" &&
+                key !== "cursor") {
+                throw new PrismaOperationTranslationError(`select.${path.join(".")}.${key} is not an Aventara relation argument, so the adapter will not emit it`);
+            }
+        }
+        if (args.where !== undefined) {
+            emitted.where = translateWhere({
+                model: context.model,
+                resource: target,
+                where: args.where,
+            });
+        }
+        if (args.orderBy !== undefined) {
+            emitted.orderBy = translateOrderBy({
+                model: context.model,
+                resource: target,
+                orderBy: args.orderBy,
+            });
+        }
+        Object.assign(emitted, translatePagination({
+            ...(typeof args.limit === "number" ? { limit: args.limit } : {}),
+            ...(typeof args.offset === "number" ? { offset: args.offset } : {}),
+            ...(isRecord(args.cursor) ? { cursor: args.cursor } : {}),
+            identifiers: identifiersOf(context, target),
+        }));
+        return emitted;
+    };
+}
+function resolveRelationTarget(context, path) {
+    let resource = context.resource;
+    for (const segment of path) {
+        const field = context.model.resources[resource]?.fields[segment];
+        if (field === undefined || field.kind !== "relation") {
+            throw new PrismaOperationTranslationError(`select.${path.join(".")}: "${segment}" is not a relation of Resource "${resource}"`);
+        }
+        resource = field.target;
+    }
+    return resource;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}