turbine-orm 0.52.0 → 0.53.0

package/dist/cjs/query/utils.d.ts

@@ -23,6 +23,36 @@ export declare function quoteIdent(name: string): string;
  * unless `key` is an OWN enumerable/non-enumerable property.
  */
 export declare function ownLookup<T>(map: Record<string, T>, key: string): T | undefined;
+/** The metadata a key needs to be resolved to a column. `TableMetadata` fits. */
+export interface ColumnNameSource {
+    columnMap: Record<string, string>;
+    reverseColumnMap?: Record<string, string>;
+    allColumns?: string[];
+}
+/**
+ * Resolve a user-supplied key to its unquoted column name, or `undefined` when
+ * the key names no column on the table.
+ *
+ * THE key-resolution rule, in one place. `QueryInterface.toColumn` is this
+ * function plus the E003 throw, so every SQL builder resolves keys through it,
+ * and the value-side passes (write coercion, the `updatedAt` injector, the
+ * nested-write foreign-key merge) call it directly rather than re-deriving the
+ * rule. They used to read `columnMap` alone, which knows only the FIELD
+ * spelling, so a key spelled as the snake_case COLUMN, which the SQL builders
+ * accept and which is the natural spelling on an introspected schema, produced
+ * correct SQL with an unprocessed value: byte-identical statement, silently
+ * different bound param.
+ *
+ * The rule: the field map first, else `camelToSnake(key)` accepted ONLY when
+ * that name is a real column. `camelToSnake` is idempotent on an already-snake
+ * string, which is what makes the column spelling legal; arbitrary strings
+ * still fail to resolve, so identifier validation is unchanged.
+ *
+ * Prototype-safe: both maps are plain objects, so a key like "constructor" or
+ * "__proto__" would otherwise return an inherited member and pass for a column
+ * name (see {@link ownLookup}).
+ */
+export declare function resolveColumnName(meta: ColumnNameSource, key: string): string | undefined;
 /**
  * Escape single quotes for use as string keys in json_build_object().
  * Doubles single quotes per SQL quoting rules.

package/dist/cjs/query/utils.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSON_WIRE_COERCION_OIDS = exports.OPERATOR_KEYS = exports.LRUCache = void 0;
 exports.quoteIdent = quoteIdent;
 exports.ownLookup = ownLookup;
+exports.resolveColumnName = resolveColumnName;
 exports.escSingleQuote = escSingleQuote;
 exports.escapeLike = escapeLike;
 exports.fnv1a64Hex = fnv1a64Hex;
@@ -54,6 +55,40 @@ function quoteIdent(name) {
 function ownLookup(map, key) {
     return Object.hasOwn(map, key) ? map[key] : undefined;
 }
+/**
+ * Resolve a user-supplied key to its unquoted column name, or `undefined` when
+ * the key names no column on the table.
+ *
+ * THE key-resolution rule, in one place. `QueryInterface.toColumn` is this
+ * function plus the E003 throw, so every SQL builder resolves keys through it,
+ * and the value-side passes (write coercion, the `updatedAt` injector, the
+ * nested-write foreign-key merge) call it directly rather than re-deriving the
+ * rule. They used to read `columnMap` alone, which knows only the FIELD
+ * spelling, so a key spelled as the snake_case COLUMN, which the SQL builders
+ * accept and which is the natural spelling on an introspected schema, produced
+ * correct SQL with an unprocessed value: byte-identical statement, silently
+ * different bound param.
+ *
+ * The rule: the field map first, else `camelToSnake(key)` accepted ONLY when
+ * that name is a real column. `camelToSnake` is idempotent on an already-snake
+ * string, which is what makes the column spelling legal; arbitrary strings
+ * still fail to resolve, so identifier validation is unchanged.
+ *
+ * Prototype-safe: both maps are plain objects, so a key like "constructor" or
+ * "__proto__" would otherwise return an inherited member and pass for a column
+ * name (see {@link ownLookup}).
+ */
+function resolveColumnName(meta, key) {
+    const mapped = ownLookup(meta.columnMap, key);
+    if (mapped)
+        return mapped;
+    const snake = (0, schema_js_1.camelToSnake)(key);
+    if (meta.reverseColumnMap && ownLookup(meta.reverseColumnMap, snake))
+        return snake;
+    if (meta.allColumns?.includes(snake))
+        return snake;
+    return undefined;
+}
 /**
  * Escape single quotes for use as string keys in json_build_object().
  * Doubles single quotes per SQL quoting rules.

package/dist/cjs/query/warn-registry.d.ts

@@ -58,6 +58,13 @@ export declare const WARN_NS: {
     readonly unorderedPage: "unorderedPage";
     /** PowDB `emitLinks` DDL skips (name/column collision, endpoint drift). */
     readonly powdbLinks: "powdbLinks";
+    /**
+     * A key on the object passed as `TurbineConfig` that is not part of the
+     * config surface (client.ts `warnUnknownConfigKeys`). Keyed on the unknown
+     * key name, so a process that builds many clients from the same misspelled
+     * config says it once.
+     */
+    readonly unknownConfigKey: "unknownConfigKey";
     /**
      * `relationLoadStrategy: 'flatten'` was asked for but a relation stayed on the
      * correlated-subquery path (relations.ts `planFlattenWith`, builder.ts

package/dist/cjs/query/warn-registry.js

@@ -99,6 +99,13 @@ exports.WARN_NS = {
     unorderedPage: 'unorderedPage',
     /** PowDB `emitLinks` DDL skips (name/column collision, endpoint drift). */
     powdbLinks: 'powdbLinks',
+    /**
+     * A key on the object passed as `TurbineConfig` that is not part of the
+     * config surface (client.ts `warnUnknownConfigKeys`). Keyed on the unknown
+     * key name, so a process that builds many clients from the same misspelled
+     * config says it once.
+     */
+    unknownConfigKey: 'unknownConfigKey',
     /**
      * `relationLoadStrategy: 'flatten'` was asked for but a relation stayed on the
      * correlated-subquery path (relations.ts `planFlattenWith`, builder.ts

package/dist/cjs/query/writes.d.ts

@@ -112,7 +112,11 @@ export declare function piiFields(_qi: BuilderCtx, meta: TableMetadata): string[
  * `Date` and lands in UTC on every engine.
  *
  * An explicit value always wins, including an explicit `null`: naming the
- * column is a statement of intent.
+ * column is a statement of intent. "Named" is decided by resolving each data
+ * key to its COLUMN, not by matching the field spelling: the SET list resolves
+ * the caller's key the same way, so a key spelled as the snake_case column used
+ * to be missed here and the injected field assigned the same column a second
+ * time (`SET "updated_at" = $1, "updated_at" = $2`, PostgreSQL 42701).
  */
 export declare function applyUpdatedAtColumns(qi: BuilderCtx, data: Record<string, unknown>): Record<string, unknown>;
 export declare function writeReturningColumns(qi: BuilderCtx): ReturningSelection;

package/dist/cjs/query/writes.js

@@ -99,10 +99,14 @@ function coerceWriteValue(qi, key, value) {
     // Cheap shape check first: the common path costs one check and no lookup.
     if (!(value instanceof Date) && !Array.isArray(value))
         return value;
-    // Non-throwing column resolution: this runs on the cache-HIT param-collect
-    // path too, where an unknown key must not turn into a different error than
-    // the build path already raises.
-    const column = (0, utils_js_1.ownLookup)(qi.tableMeta.columnMap, key);
+    // THE key-resolution rule, shared with `toColumn` (the SQL side of this very
+    // statement) so the two can never disagree about which column a key names:
+    // resolving through `columnMap` alone missed the snake_case COLUMN spelling
+    // that the SQL builders accept, so those writes bound an unprocessed value
+    // under an identical statement. Non-throwing, because this also runs on the
+    // cache-HIT param-collect path, where an unknown key must not turn into a
+    // different error than the build path already raises.
+    const column = (0, utils_js_1.resolveColumnName)(qi.tableMeta, key);
     if (!column)
         return value;
     // Metadata generated by an older Turbine still carries per-column types
@@ -751,22 +755,43 @@ function piiFields(_qi, meta) {
  * `Date` and lands in UTC on every engine.
  *
  * An explicit value always wins, including an explicit `null`: naming the
- * column is a statement of intent.
+ * column is a statement of intent. "Named" is decided by resolving each data
+ * key to its COLUMN, not by matching the field spelling: the SET list resolves
+ * the caller's key the same way, so a key spelled as the snake_case column used
+ * to be missed here and the injected field assigned the same column a second
+ * time (`SET "updated_at" = $1, "updated_at" = $2`, PostgreSQL 42701).
  */
 function applyUpdatedAtColumns(qi, data) {
     const tagged = qi.tableMeta.columns.filter((c) => c.updatedAt);
     if (tagged.length === 0)
         return data;
+    const named = namedColumns(qi.tableMeta, data);
     let out = null;
     const now = new Date();
     for (const col of tagged) {
-        if (Object.hasOwn(data, col.field) && data[col.field] !== undefined)
+        if (named.has(col.name))
             continue;
         out ??= { ...data };
         out[col.field] = now;
     }
     return out ?? data;
 }
+/**
+ * The set of COLUMNS a `data` object names, under any accepted spelling of each
+ * key. A key set to `undefined` names nothing (see {@link definedKeys}), and a
+ * key that resolves to no column is left to the SQL builder's own E003.
+ */
+function namedColumns(meta, data) {
+    const out = new Set();
+    for (const key of Object.keys(data)) {
+        if (data[key] === undefined)
+            continue;
+        const column = (0, utils_js_1.resolveColumnName)(meta, key);
+        if (column)
+            out.add(column);
+    }
+    return out;
+}
 function writeReturningColumns(qi) {
     const piiCols = piiColumns(qi, qi.tableMeta);
     if (piiCols.size === 0)

package/dist/client.js

@@ -27,7 +27,8 @@ import { setErrorMessageMode, TimeoutError, UnsupportedFeatureError, ValidationE
 import { ObserveEngine } from './observe.js';
 import { executePipeline, pipelineSupported } from './pipeline.js';
 import { QueryInterface, } from './query/index.js';
-import { quoteIdent } from './query/utils.js';
+import { closestName, quoteIdent } from './query/utils.js';
+import { shouldWarnOnce, WARN_NS } from './query/warn-registry.js';
 import { createSubscription, validateChannel, } from './realtime.js';
 import { buildTypedSql, TypedSqlQuery } from './typed-sql.js';
 export async function withRetry(fn, options) {
@@ -54,6 +55,154 @@ export async function withRetry(fn, options) {
     }
     throw lastError;
 }
+// ---------------------------------------------------------------------------
+// Unknown-config-key diagnostics
+// ---------------------------------------------------------------------------
+/**
+ * Every `TurbineConfig` key, as runtime data. TypeScript erases the interface,
+ * so the key set has to exist as a value; `Record<keyof TurbineConfig, true>`
+ * makes the compiler own it in BOTH directions: a field added to the interface
+ * fails typecheck until it is listed here, and a key listed here that is not a
+ * field fails as an excess property. So this can never drift into warning about
+ * a real option.
+ */
+const TURBINE_CONFIG_KEYS = {
+    pool: true,
+    connectionString: true,
+    host: true,
+    port: true,
+    database: true,
+    user: true,
+    password: true,
+    ssl: true,
+    poolSize: true,
+    idleTimeoutMs: true,
+    connectionTimeoutMs: true,
+    max: true,
+    idleTimeoutMillis: true,
+    connectionTimeoutMillis: true,
+    logging: true,
+    defaultLimit: true,
+    warnOnUnlimited: true,
+    utcTimestamps: true,
+    scopedConnect: true,
+    relationLoadStrategy: true,
+    stableRelationOrder: true,
+    implicitPkOrdering: true,
+    autoToOneJoinMaxRows: true,
+    autoRoundTripMs: true,
+    jsonEncoding: true,
+    errorMessages: true,
+    logQueryParams: true,
+    preparedStatements: true,
+    sqlCache: true,
+    sqlCacheSize: true,
+    dialect: true,
+    replicas: true,
+    globalFilters: true,
+};
+/**
+ * {@link TURBINE_CONFIG_KEYS} as a lookup. A `Set` rather than an `in` test on
+ * the record, so an inherited `Object.prototype` name (`toString`, `constructor`)
+ * is treated as the unknown key it is.
+ */
+const CONFIG_KEY_SET = new Set(Object.keys(TURBINE_CONFIG_KEYS));
+/**
+ * Keys that are legitimately present on a config object but are not public
+ * `TurbineConfig` fields:
+ *
+ *   - `queryInterfaceFactory`: the non-SQL-backend seam. `turbinePowDB` sets it
+ *     through a cast so `table()` builds a `PowqlInterface`; it is `@internal`,
+ *     deliberately absent from the public interface, and must not warn.
+ *   - `schema`: `turbine.config.*` files carry a Postgres schema NAME for the
+ *     CLI, and that same object is routinely spread into the client factory.
+ *     The client ignores it (its schema metadata is the second argument), and
+ *     shouting about a documented CLI field would be pure noise.
+ *   - `url`: the connection-string spelling used by the CLI config and by the
+ *     engine factories' first argument. Same story as `schema`.
+ */
+const NON_CONFIG_KEYS = new Set(['queryInterfaceFactory', 'schema', 'url']);
+/** camelCase name → its lowercased words (`logQueryParams` → log, query, params). */
+function camelWords(name) {
+    return name
+        .split(/(?=[A-Z])/)
+        .map((w) => w.toLowerCase())
+        .filter(Boolean);
+}
+/**
+ * The real config key `key` most likely meant, or null when nothing is close.
+ *
+ * {@link closestName} (the same helper the unknown-COLUMN message uses) decides
+ * first, so both diagnostics rank near-misses identically. It is bounded by edit
+ * distance, which covers typos but not the miss this warning exists for: a
+ * guessed name that omits a whole word. `logParams` is five edits from
+ * `logQueryParams`, past the bound, yet it names the same words in the same
+ * order, so a second pass accepts a candidate whose camelCase words CONTAIN the
+ * guess's words in order, preferring the one that adds fewest words.
+ */
+function suggestConfigKey(key) {
+    const direct = closestName(key, CONFIG_KEY_SET);
+    if (direct)
+        return direct;
+    const wanted = camelWords(key);
+    if (wanted.length < 2)
+        return null;
+    let best = null;
+    let bestExtra = Number.POSITIVE_INFINITY;
+    for (const candidate of CONFIG_KEY_SET) {
+        const words = camelWords(candidate);
+        if (words.length <= wanted.length)
+            continue;
+        let i = 0;
+        for (const w of words)
+            if (w === wanted[i])
+                i++;
+        if (i !== wanted.length)
+            continue;
+        const extra = words.length - wanted.length;
+        if (extra < bestExtra) {
+            bestExtra = extra;
+            best = candidate;
+        }
+    }
+    return best;
+}
+/**
+ * Dev-mode notice for a key on the config object that is not part of the config
+ * surface.
+ *
+ * An unknown key is silently ignored (JavaScript objects have no schema), which
+ * makes a typo or a wrong guess indistinguishable from a broken feature: a
+ * caller who wants query parameters in `$on('query')` events and reaches for a
+ * plausible-sounding `logParams` sees nothing happen and concludes the feature
+ * does not work, rather than that the option is spelled `logQueryParams`.
+ *
+ * Deliberately a warning, never an error. An app compiled against a NEWER
+ * turbine that passes a key this version has not heard of must keep running,
+ * and the whole check is wrapped so that a hostile / exotic config object
+ * (a Proxy whose `ownKeys` throws) cannot take down the constructor either.
+ * Dev-only (`NODE_ENV !== 'production'`) and once per key per process, like the
+ * other advisory diagnostics.
+ */
+function warnUnknownConfigKeys(config) {
+    if (process.env.NODE_ENV === 'production')
+        return;
+    try {
+        for (const key of Object.keys(config)) {
+            if (CONFIG_KEY_SET.has(key) || NON_CONFIG_KEYS.has(key))
+                continue;
+            if (!shouldWarnOnce(WARN_NS.unknownConfigKey, key))
+                continue;
+            const suggestion = suggestConfigKey(key);
+            console.warn(`[turbine] Unknown option "${key}" in the config passed to TurbineClient, it is ignored.` +
+                (suggestion ? ` Did you mean "${suggestion}"?` : ''));
+        }
+    }
+    catch {
+        // Key enumeration is the only thing that can fail here, and a diagnostic
+        // must never be the reason a client fails to construct.
+    }
+}
 /** Maps isolation level names to SQL */
 const ISOLATION_LEVELS = {
     ReadUncommitted: 'READ UNCOMMITTED',
@@ -378,6 +527,9 @@ export class TurbineClient {
             }
             break;
         }
+        // Name any key on the config object that is not part of the config surface
+        // (dev only, once per key, never throws). See warnUnknownConfigKeys.
+        warnUnknownConfigKeys(config);
         /**
          * Parse int8 (bigint, OID 20) as JavaScript number instead of string.
          * Safe for values up to Number.MAX_SAFE_INTEGER (9,007,199,254,740,991).

package/dist/nested-write.js

@@ -12,6 +12,7 @@
  * `NestedWriteContext`.
  */
 import { CircularRelationError, describeTargetForMessage, NotFoundError, RelationError, UnsupportedFeatureError, ValidationError, } from './errors.js';
+import { resolveColumnName } from './query/utils.js';
 import { normalizeKeyColumns } from './schema.js';
 const MAX_DEPTH = 10;
 const CREATE_ONLY_OPS = new Set(['create', 'connect', 'connectOrCreate']);
@@ -75,10 +76,50 @@ export function injectForeignKey(childData, relation, parentRow, schema) {
         const refCol = refs[i];
         const refField = schema.tables[relation.from]?.reverseColumnMap[refCol] ?? refCol;
         const fkField = childTable?.reverseColumnMap[fkCol] ?? fkCol;
-        result[fkField] = parentRow[refField];
+        assignByColumn(result, childTable, fkField, parentRow[refField]);
     }
     return result;
 }
+/**
+ * Set `field` on `target`, first dropping any OTHER key that names the SAME
+ * column.
+ *
+ * The engine always writes the canonical FIELD spelling, while a caller's own
+ * `data` may legally spell the same column its snake_case way (the write
+ * builders resolve both). Overwriting only the identical key left both in the
+ * object, and the INSERT/UPDATE then named one column twice, which PostgreSQL
+ * refuses (42701 "specified more than once"). Dropping the alias makes the
+ * column spelling behave exactly as the field spelling always did: the value the
+ * relation dictates wins.
+ *
+ * Only SCALAR keys are droppable. A relation is resolved to a column by the very
+ * same rule (nothing stops a schema from naming a relation the way a column is
+ * spelled), but a relation key carries a nested write rather than a value, so
+ * dropping it would discard the whole operation silently, a strictly worse
+ * outcome than the duplicate-column error this drop exists to prevent. The
+ * relation-shape test matches {@link splitData}, so a key routed to `relations`
+ * there is never treated as an alias here.
+ */
+function assignByColumn(target, meta, field, value) {
+    const column = meta && resolveColumnName(meta, field);
+    if (column) {
+        for (const key of Object.keys(target)) {
+            if (key === field || isRelationEntry(meta, key, target[key]))
+                continue;
+            if (resolveColumnName(meta, key) === column)
+                delete target[key];
+        }
+    }
+    target[field] = value;
+}
+/** Does `key` name a relation on `meta` AND carry a nested-write payload? */
+function isRelationEntry(meta, key, value) {
+    return (Object.hasOwn(meta.relations, key) &&
+        value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        !(value instanceof Date));
+}
 /**
  * Split rows destined for `createMany` into CONTIGUOUS runs that each name the
  * same fields.
@@ -741,10 +782,15 @@ export async function executeNestedCreate(ctx, tableName, data, depth = 0, path
             assertManyToManyOpsSupported(relName, rel, ops);
         }
     }
-    // Insert the parent row (scalars + resolved belongsTo foreign keys)
-    const parentRow = (await ctx.tx.table(tableName).create({
-        data: { ...scalars, ...belongsToFks },
-    }));
+    // Insert the parent row (scalars + resolved belongsTo foreign keys). The
+    // resolved keys win over a caller-supplied value for the same column under
+    // either spelling (see assignByColumn), so `{ authorId: 1, author: { connect } }`
+    // and `{ author_id: 1, author: { connect } }` both take the connected row.
+    const parentData = { ...scalars };
+    for (const [field, value] of Object.entries(belongsToFks)) {
+        assignByColumn(parentData, tableMeta, field, value);
+    }
+    const parentRow = (await ctx.tx.table(tableName).create({ data: parentData }));
     // Process hasMany / hasOne relations, their FK lives on the CHILD, so they
     // need the parent row to exist first.
     for (const [relName, ops] of Object.entries(relations)) {

package/dist/prisma-compat.d.ts

@@ -37,7 +37,15 @@
  * These cannot be faithfully translated and are not attempted; each throws or is
  * documented rather than silently returning wrong data:
  *
- * - `$extends` / client extensions, `$use` with Prisma's middleware param shape.
+ * - **`$extends` beyond `client` + `model`.** Client extensions ARE supported for
+ *   those two components (plus the `Prisma.defineExtension` callback form), and
+ *   return a new client whose delegates, `$transaction` and raw surface all
+ *   survive. The `query` (interception) and `result` (computed fields)
+ *   components, and any component this adapter does not recognize, throw an
+ *   {@link UnsupportedFeatureError} naming the component AT `$extends` TIME
+ *   rather than being accepted and quietly not applied.
+ * - `$use` with Prisma's middleware param shape (Turbine's own `client.$use` is
+ *   the supported interception seam).
  * - `instanceof PrismaClientKnownRequestError`, `.meta`/message byte parity
  *   (opt into `prismaErrorCodes` for a `.code` like `P2002`, without pretending
  *   `instanceof` identity).
@@ -197,6 +205,19 @@ export declare const Prisma: {
     raw(sql: string): Sql;
     /** An empty fragment. */
     empty: Sql;
+    /**
+     * The extension context of `this` inside a client / model extension method.
+     * Turbine binds extension members directly onto the client and delegate
+     * objects, so the context IS `this`; the identity function exists so migrated
+     * `Prisma.getExtensionContext(this).$name` call sites keep working.
+     */
+    getExtensionContext<T>(that: T): T;
+    /**
+     * Type-preserving passthrough for `Prisma.defineExtension(ext)`. Prisma uses
+     * it purely for inference; the value is returned unchanged, so both the object
+     * and the callback form reach `$extends` intact.
+     */
+    defineExtension<E>(ext: E): E;
 };
 /** Options for {@link createPrismaCompatClient}. */
 export interface PrismaCompatOptions {
@@ -269,12 +290,69 @@ export interface PrismaCompatRawSurface {
     $executeRaw(strings: TemplateStringsArray, ...values: unknown[]): Promise<number>;
     $executeRawUnsafe(sql: string, ...params: unknown[]): Promise<number>;
 }
-/** The client-level surface (`$transaction` / raw), added to the model map. */
+/**
+ * A Prisma client extension, restricted to the two components this adapter can
+ * honour faithfully.
+ *
+ * `client` members land on the returned client; `model` members land on the
+ * named model's delegate (under BOTH spellings), with `$allModels` applying to
+ * every delegate. The `query` and `result` components are declared `never` so
+ * passing one is a compile error, and {@link PrismaCompatClient.$extends} also
+ * refuses them at runtime with an {@link UnsupportedFeatureError} naming the
+ * component: an extension that was accepted and then quietly not applied would
+ * be far worse than one that is refused.
+ */
+export interface PrismaCompatExtension {
+    /** Optional extension name, accepted and otherwise unused (as in Prisma). */
+    name?: string;
+    /** Extra client-level members, e.g. `{ $healthCheck() { … } }`. */
+    client?: Record<string, unknown>;
+    /** Extra delegate members per Prisma model name, plus `$allModels`. */
+    model?: Record<string, Record<string, unknown>>;
+    /** Not supported, see {@link PrismaCompatExtension}. */
+    query?: never;
+    /** Not supported, see {@link PrismaCompatExtension}. */
+    result?: never;
+    /** Any other component is refused at runtime by name. */
+    [component: string]: unknown;
+}
+/** Members an extension contributes to the delegate for Prisma model `K`. */
+type ModelMembersOf<M, K extends string> = (K extends keyof M ? M[K] : unknown) & (Uncapitalize<K> extends keyof M ? M[Uncapitalize<K>] : unknown) & ('$allModels' extends keyof M ? M['$allModels'] : unknown);
+type ExtraModelMembers<E, K extends string> = E extends {
+    model: infer M;
+} ? ModelMembersOf<M, K> : unknown;
+/**
+ * The client {@link PrismaCompatClient.$extends} returns: the same surface with
+ * the extension's `client` members on the client and its `model` members on
+ * every matching delegate (both spellings).
+ */
+export type PrismaCompatExtendedClient<S extends Record<string, PrismaModelTypes>, E> = {
+    [K in keyof S]: PrismaModelDelegate<S[K]> & ExtraModelMembers<E, K & string>;
+} & {
+    [K in keyof S as Uncapitalize<K & string>]: PrismaModelDelegate<S[K]> & ExtraModelMembers<E, K & string>;
+} & PrismaCompatClientBase<S> & (E extends {
+    client: infer C;
+} ? C : unknown);
+/** The client-level surface (`$transaction` / raw / `$extends`), added to the model map. */
 export interface PrismaCompatClientBase<S extends Record<string, PrismaModelTypes> = Record<string, PrismaModelTypes>> extends PrismaCompatRawSurface {
     $transaction<R>(fn: (tx: PrismaCompatTransactionClient<S>) => Promise<R>, options?: PrismaCompatTxOptions): Promise<R>;
     $transaction<P extends readonly PromiseLike<unknown>[]>(promises: readonly [...P]): Promise<{
         [K in keyof P]: Awaited<P[K]>;
     }>;
+    /**
+     * Prisma's callback form (`Prisma.defineExtension((client) => …)`): the
+     * function is called with this client and its return value is the result,
+     * exactly as in Prisma. Declared first so a function argument never matches
+     * the all-optional object overload below.
+     */
+    $extends<R>(extension: (client: PrismaCompatClient<S>) => R): R;
+    /**
+     * Extend the client with a {@link PrismaCompatExtension}. Returns a NEW client
+     * (this one is untouched) carrying the extension's `client` and `model`
+     * members; the returned client is itself extendable. `query` and `result`
+     * extensions throw, see {@link PrismaCompatExtension}.
+     */
+    $extends<E extends PrismaCompatExtension>(extension: E): PrismaCompatExtendedClient<S, E>;
     $connect(): Promise<void>;
     $disconnect(): Promise<void>;
 }