turbine-orm 0.40.1 → 0.41.0

package/dist/query/types.d.ts

@@ -15,13 +15,30 @@ export type OrderDirection = 'asc' | 'desc';
  *     relation (`WHERE fk = ANY($1)`), stitching children client-side. D levels
  *     cost D extra round-trips, but each is a single key-set lookup and rows come
  *     back flat (a win when FK columns are unindexed or result sets are huge).
+ *   - `'auto'` (the implicit default on SQL engines since 0.41): per relation,
+ *     use `'join'` unless the introspected metadata PROVES the probe columns are
+ *     unindexed, in which case that relation falls back to the batched loader
+ *     (where a correlated per-parent scan would be pathological). Requires
+ *     DB-backed index metadata (a generated / introspected client); a code-first
+ *     `defineSchema`-only client has no index info to prove anything, so `'auto'`
+ *     behaves exactly like `'join'` there. An EXPLICIT `'join'` or `'batched'` at
+ *     the client or query level always wins and disables the per-relation
+ *     fallback. Output is byte-for-byte identical to `'join'` (the batched loader
+ *     guarantees the same result SHAPE); child-array order for a to-many relation
+ *     WITHOUT an `orderBy` may differ from the join plan (order was never
+ *     guaranteed without `orderBy`, see `stableRelationOrder` to pin it).
+ *     Composite-key relations stay on the join plan (the batched loader does not
+ *     support them). Engagement emits a once-per-relation dev note and a
+ *     `strategy` tag on the query event.
  *
  * Precedence: per-query arg > client `relationLoadStrategy` config > the engine
- * default. On SQL engines the default is `'join'`; on PowDB the default is the
+ * default. On SQL engines the default is `'auto'`; on PowDB the default is the
  * batched loaders (an ineligible relation falls back to them per-relation and
- * silently even when `'join'` is requested).
+ * silently even when `'join'` is requested). On PowDB, `'auto'` resolves to
+ * PowDB's own existing default (loaders / nested projections); it never selects
+ * a distinct PowQL code path.
  */
-export type RelationLoadStrategy = 'join' | 'batched';
+export type RelationLoadStrategy = 'join' | 'batched' | 'auto';
 /**
  * Reference to ANOTHER COLUMN of the same table inside a where operator,
  * enabling column-to-column comparison:
@@ -330,6 +347,8 @@ export interface FindUniqueArgs<T, R extends object = {}, W extends TypedWithCla
     timeout?: number;
     /** Override the client's relation-loading strategy for this query. See {@link RelationLoadStrategy}. */
     relationLoadStrategy?: RelationLoadStrategy;
+    /** Override the client's {@link TurbineConfig.stableRelationOrder} for this query. */
+    stableRelationOrder?: boolean;
     /** Opt out of configured {@link GlobalFilters}. See {@link SkipGlobalFilters}. */
     skipGlobalFilters?: SkipGlobalFilters;
     /** Include PII-tagged columns in the result. See {@link FindManyArgs.includePii}. */
@@ -353,6 +372,15 @@ export interface FindManyArgs<T, R extends object = {}, W extends TypedWithClaus
     timeout?: number;
     /** Override the client's relation-loading strategy for this query. See {@link RelationLoadStrategy}. */
     relationLoadStrategy?: RelationLoadStrategy;
+    /**
+     * Override the client's {@link TurbineConfig.stableRelationOrder} for this
+     * query. When `true`, every to-many `with` relation that has no explicit
+     * `orderBy` is loaded ordered by the target table's primary key ascending, so
+     * unordered child arrays come back in a deterministic order. An explicit
+     * per-relation `orderBy` always wins. Off by default; when off the emitted SQL
+     * is byte-identical to before.
+     */
+    stableRelationOrder?: boolean;
     /** Opt out of configured {@link GlobalFilters}. See {@link SkipGlobalFilters}. */
     skipGlobalFilters?: SkipGlobalFilters;
     /**
@@ -732,8 +760,16 @@ export interface GroupByArgs<T> {
      * (`SELECT DISTINCT ON … ORDER BY …` row source). See {@link GroupByDistinctOn}.
      */
     distinctOn?: GroupByDistinctOn<T>;
-    /** Include count of each group */
-    _count?: true;
+    /**
+     * Count each group. `true` (or omitted) → `_count: number` (COUNT(*)). The
+     * record form counts per selection: the reserved `_all: true` key → COUNT(*),
+     * and each entity field key → COUNT(that column), yielding
+     * `_count: { _all: n, field: n }` (Prisma parity). Ordering/HAVING on `_count`
+     * stays available whenever COUNT(*) is selected (`true`, omitted, or `_all`).
+     */
+    _count?: true | ({
+        _all?: true;
+    } & Partial<Record<keyof T & string, boolean>>);
     /** Sum of numeric fields (or JSON paths: see {@link JsonPathAggregateTarget}) in each group */
     _sum?: GroupByAggregateSpec<T>;
     /** Average of numeric fields (or JSON paths) in each group */
@@ -817,14 +853,39 @@ type GroupByMinMaxPart<T, A, Key extends '_min' | '_max'> = A extends {
  */
 export type GroupByResult<T, A> = {
     [K in GroupByFieldKeys<T, A>]: T[K];
-} & {
+} & GroupByCountPart<A> & GroupBySumAvgPart<A, '_sum'> & GroupBySumAvgPart<A, '_avg'> & GroupByMinMaxPart<T, A, '_min'> & GroupByMinMaxPart<T, A, '_max'>;
+/**
+ * The `_count` block on a groupBy result row. Scalar `_count: true` (or an
+ * omitted `_count`, which still selects COUNT(*) by default) yields a plain
+ * `number`; the record form (`_count: { _all: true, field: true }`) yields a
+ * per-selection object `{ _all: number, field: number }` (Prisma parity). Kept
+ * additive: existing `_count: true` / no-`_count` calls still infer `number`.
+ */
+type GroupByCountPart<A> = A extends {
+    _count: infer C;
+} ? C extends true ? {
+    _count: number;
+} : [C] extends [object] ? {
+    _count: {
+        [K in keyof C & string]: number;
+    };
+} : {
+    _count: number;
+} : {
     _count: number;
-} & GroupBySumAvgPart<A, '_sum'> & GroupBySumAvgPart<A, '_avg'> & GroupByMinMaxPart<T, A, '_min'> & GroupByMinMaxPart<T, A, '_max'>;
+};
 /** Arguments for the standalone aggregate method */
 export interface AggregateArgs<T> {
     where?: WhereClause<T>;
-    /** Count all rows matching the filter */
-    _count?: true | Partial<Record<keyof T & string, boolean>>;
+    /**
+     * Count rows. `true` → `_count: number` (COUNT(*)). The record form counts per
+     * selection: the reserved `_all: true` key → COUNT(*), and each entity field
+     * key → COUNT(that column) (non-null count), yielding
+     * `_count: { _all: n, field: n }` (Prisma parity).
+     */
+    _count?: true | ({
+        _all?: true;
+    } & Partial<Record<keyof T & string, boolean>>);
     /** Sum of numeric fields */
     _sum?: Partial<Record<keyof T & string, boolean>>;
     /** Average of numeric fields */

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

@@ -0,0 +1,57 @@
+/**
+ * turbine-orm, process-wide once-per-key dev-warning dedupe registry.
+ *
+ * Several dev-only diagnostics (the missing-FK-index warning in relations.ts,
+ * the `relationLoadStrategy: 'auto'` engagement note, the deep-`with` warning)
+ * must fire AT MOST ONCE per distinct key for the life of the process. A
+ * module-level `Set` almost does this, but it is defeated by the two field
+ * realities this package actually ships into:
+ *
+ *   1. **Dual-package loading.** Turbine ships ESM (`dist/`) AND CJS
+ *      (`dist/cjs/`). A mixed `require`/`import` graph (a compat layer, a tool
+ *      that loads both) instantiates the module twice, giving two independent
+ *      `Set`s that each warn once, a double warning.
+ *   2. **Bundler / HMR re-evaluation.** Under Next.js dev the module is
+ *      re-evaluated per recompile, resetting a module-level `Set` and making the
+ *      warning appear to fire every time.
+ *
+ * Hanging the registry off `globalThis` under a `Symbol.for(...)` key gives every
+ * module copy in the realm ONE shared registry (cross-copy identity without
+ * polluting enumerable globals), and `globalThis` survives webpack recompiles
+ * because the realm persists, which is exactly what fixes the every-recompile
+ * firing in dev servers. Per-process firing (worker threads, separate processes)
+ * is acceptable and stays.
+ *
+ * Bounded: each namespace stops recording AND stops warning once it reaches
+ * {@link WARN_ONCE_CAP} distinct keys. A schema with 500+ distinct unindexed
+ * relations has long since gotten the message, and the cap prevents unbounded
+ * growth if metadata objects are churned dynamically. (Clearing on overflow
+ * would be wrong, it would re-warn.)
+ */
+/** Per-namespace cap on distinct recorded keys (see module doc). */
+export declare const WARN_ONCE_CAP = 500;
+/**
+ * Record `(ns, key)` and report whether THIS call is the first to see it
+ * process-wide. Returns `true` exactly once per distinct key (the caller should
+ * emit its warning then), `false` on every subsequent call for that key, and
+ * `false` once the namespace has recorded {@link WARN_ONCE_CAP} distinct keys
+ * (bounded growth; the warning simply stops rather than re-firing).
+ */
+export declare function shouldWarnOnce(ns: string, key: string): boolean;
+/** True when `(ns, key)` has already been recorded (no mutation). */
+export declare function hasWarnedOnce(ns: string, key: string): boolean;
+/**
+ * @internal Test-only: clear one namespace, or the whole registry when `ns` is
+ * omitted. Lets a single test process verify that a warning fires once and then
+ * re-verify after a reset without spawning a new process.
+ */
+export declare function resetWarnOnce(ns?: string): void;
+/** Namespace constants so callers never typo a bare string. */
+export declare const WARN_NS: {
+    /** Missing-FK-index runtime warning (relations.ts `buildRelationSubquery`). */
+    readonly unindexedRelation: "unindexedRelation";
+    /** `relationLoadStrategy: 'auto'` batched-fallback engagement note. */
+    readonly autoStrategy: "autoStrategy";
+    /** Deep-`with` (depth > 5) advisory (builder.ts `findMany`). */
+    readonly deepWith: "deepWith";
+};

package/dist/query/warn-registry.js

@@ -0,0 +1,92 @@
+/**
+ * turbine-orm, process-wide once-per-key dev-warning dedupe registry.
+ *
+ * Several dev-only diagnostics (the missing-FK-index warning in relations.ts,
+ * the `relationLoadStrategy: 'auto'` engagement note, the deep-`with` warning)
+ * must fire AT MOST ONCE per distinct key for the life of the process. A
+ * module-level `Set` almost does this, but it is defeated by the two field
+ * realities this package actually ships into:
+ *
+ *   1. **Dual-package loading.** Turbine ships ESM (`dist/`) AND CJS
+ *      (`dist/cjs/`). A mixed `require`/`import` graph (a compat layer, a tool
+ *      that loads both) instantiates the module twice, giving two independent
+ *      `Set`s that each warn once, a double warning.
+ *   2. **Bundler / HMR re-evaluation.** Under Next.js dev the module is
+ *      re-evaluated per recompile, resetting a module-level `Set` and making the
+ *      warning appear to fire every time.
+ *
+ * Hanging the registry off `globalThis` under a `Symbol.for(...)` key gives every
+ * module copy in the realm ONE shared registry (cross-copy identity without
+ * polluting enumerable globals), and `globalThis` survives webpack recompiles
+ * because the realm persists, which is exactly what fixes the every-recompile
+ * firing in dev servers. Per-process firing (worker threads, separate processes)
+ * is acceptable and stays.
+ *
+ * Bounded: each namespace stops recording AND stops warning once it reaches
+ * {@link WARN_ONCE_CAP} distinct keys. A schema with 500+ distinct unindexed
+ * relations has long since gotten the message, and the cap prevents unbounded
+ * growth if metadata objects are churned dynamically. (Clearing on overflow
+ * would be wrong, it would re-warn.)
+ */
+const REGISTRY_KEY = Symbol.for('turbine.warnOnce.registry');
+/** Per-namespace cap on distinct recorded keys (see module doc). */
+export const WARN_ONCE_CAP = 500;
+function registry() {
+    const g = globalThis;
+    let reg = g[REGISTRY_KEY];
+    if (!reg) {
+        reg = Object.create(null);
+        g[REGISTRY_KEY] = reg;
+    }
+    return reg;
+}
+function namespaceSet(ns) {
+    const reg = registry();
+    let set = reg[ns];
+    if (!set) {
+        set = new Set();
+        reg[ns] = set;
+    }
+    return set;
+}
+/**
+ * Record `(ns, key)` and report whether THIS call is the first to see it
+ * process-wide. Returns `true` exactly once per distinct key (the caller should
+ * emit its warning then), `false` on every subsequent call for that key, and
+ * `false` once the namespace has recorded {@link WARN_ONCE_CAP} distinct keys
+ * (bounded growth; the warning simply stops rather than re-firing).
+ */
+export function shouldWarnOnce(ns, key) {
+    const set = namespaceSet(ns);
+    if (set.has(key))
+        return false;
+    if (set.size >= WARN_ONCE_CAP)
+        return false;
+    set.add(key);
+    return true;
+}
+/** True when `(ns, key)` has already been recorded (no mutation). */
+export function hasWarnedOnce(ns, key) {
+    return namespaceSet(ns).has(key);
+}
+/**
+ * @internal Test-only: clear one namespace, or the whole registry when `ns` is
+ * omitted. Lets a single test process verify that a warning fires once and then
+ * re-verify after a reset without spawning a new process.
+ */
+export function resetWarnOnce(ns) {
+    if (ns === undefined) {
+        globalThis[REGISTRY_KEY] = undefined;
+        return;
+    }
+    registry()[ns] = undefined;
+}
+/** Namespace constants so callers never typo a bare string. */
+export const WARN_NS = {
+    /** Missing-FK-index runtime warning (relations.ts `buildRelationSubquery`). */
+    unindexedRelation: 'unindexedRelation',
+    /** `relationLoadStrategy: 'auto'` batched-fallback engagement note. */
+    autoStrategy: 'autoStrategy',
+    /** Deep-`with` (depth > 5) advisory (builder.ts `findMany`). */
+    deepWith: 'deepWith',
+};

package/dist/query/writes.js

@@ -12,6 +12,7 @@
  */
 import { NotFoundError, OptimisticLockError, ValidationError } from '../errors.js';
 import { camelToSnake, snakeToCamel } from '../schema.js';
+import { expandCompoundUniqueWhere } from './compound-unique.js';
 import { UPDATE_OPERATOR_KEYS } from './filters.js';
 import * as whereMod from './where.js';
 /**
@@ -133,7 +134,10 @@ export function buildUpdate(qi, args) {
     qi.currentSkip = args.skipGlobalFilters;
     const dataObj = args.data;
     assertNoGeneratedColumns(qi, dataObj, 'update');
-    const userWhere = args.where;
+    // Prisma compound-unique selector (e.g. `{ orgId_userId: { orgId, userId } }`)
+    // → the column conjunction, before the empty-`where` guard so the expanded
+    // members count as a real predicate.
+    const userWhere = expandCompoundUniqueWhere(qi.tableMeta, args.where);
     const lock = args.optimisticLock;
     // The empty-`where` guard checks the USER predicate only — a global filter
     // must never turn an unguarded mass update into an allowed one.
@@ -239,9 +243,11 @@ export function buildUpdate(qi, args) {
 export function buildDelete(qi, args) {
     assertWritable(qi, 'delete');
     qi.currentSkip = args.skipGlobalFilters;
+    // Prisma compound-unique selector → the column conjunction (before the guard).
+    const userWhere = expandCompoundUniqueWhere(qi.tableMeta, args.where);
     // Guard the USER predicate (a global filter must not satisfy the guard).
-    whereMod.assertMutationHasPredicate(qi, 'delete', whereMod.userPredicateIsEmpty(qi, args.where) ? '' : ' WHERE x', args.allowFullTableScan);
-    const whereObj = (whereMod.mergeGlobalFilter(qi, args.where) ?? {});
+    whereMod.assertMutationHasPredicate(qi, 'delete', whereMod.userPredicateIsEmpty(qi, userWhere) ? '' : ' WHERE x', args.allowFullTableScan);
+    const whereObj = (whereMod.mergeGlobalFilter(qi, userWhere) ?? {});
     const whereFp = whereMod.fingerprintWhere(qi, whereObj);
     const ck = `d:${whereFp}${whereMod.globalFilterCacheSegment(qi)}`;
     const params = [];
@@ -292,6 +298,8 @@ export function buildUpsert(qi, args) {
     assertNoGeneratedColumns(qi, args.create, 'upsert');
     assertNoGeneratedColumns(qi, args.update, 'upsert');
     qi.currentSkip = args.skipGlobalFilters;
+    // Prisma compound-unique selector on the conflict target → its member columns.
+    const upsertWhere = expandCompoundUniqueWhere(qi.tableMeta, args.where);
     // Build the INSERT part from create data
     const createEntries = Object.entries(args.create).filter(([, v]) => v !== undefined);
     const columns = createEntries.map(([k]) => qi.toSqlColumn(k));
@@ -299,7 +307,7 @@ export function buildUpsert(qi, args) {
     // Enum columns get an explicit `::"EnumName"` cast (see enumTypeForColumn).
     const placeholders = createEntries.map(([k], i) => `${qi.p(i + 1)}${whereMod.enumCastSuffix(qi, qi.toColumn(k))}`);
     // The conflict target comes from `where` keys — must be unique/PK columns
-    const conflictKeys = Object.keys(args.where).filter((k) => args.where[k] !== undefined);
+    const conflictKeys = Object.keys(upsertWhere).filter((k) => upsertWhere[k] !== undefined);
     const conflictColumns = conflictKeys.map((k) => qi.toSqlColumn(k));
     // Build the UPDATE SET part
     const updateEntries = Object.entries(args.update).filter(([, v]) => v !== undefined);
@@ -350,7 +358,7 @@ export function buildUpsert(qi, args) {
         reselect: qi.dialect.resultStrategy === 'reselect'
             ? async (exec) => {
                 await exec(sql, params);
-                const sel = buildReselectByWhere(qi, (whereMod.mergeGlobalFilter(qi, args.where) ?? {}));
+                const sel = buildReselectByWhere(qi, (whereMod.mergeGlobalFilter(qi, upsertWhere) ?? {}));
                 return exec(sel.sql, sel.params);
             }
             : undefined,

package/dist/schema.d.ts

@@ -220,3 +220,78 @@ export declare function camelToSnake(s: string): string;
 export declare function snakeToPascal(s: string): string;
 /** Naive singularize: "posts" → "post", "categories" → "category" */
 export declare function singularize(s: string): string;
+/**
+ * Return a copy of `schema` in which every column's TypeScript **field** name is
+ * the raw database column name (snake_case) instead of the camelCased default,
+ * i.e. `user_id` stays `user_id` rather than becoming `userId`.
+ *
+ * This is a PURE, generate-time transform with ZERO runtime changes: it only
+ * rewrites `column.field` and rebuilds each table's `columnMap` /
+ * `reverseColumnMap` as IDENTITY maps (`user_id → user_id`). Because every
+ * runtime surface resolves column names through those maps (`toColumn`,
+ * `parseRow`, relation `json_build_object` keys, batched-loader stitching,
+ * positional decoding, aggregate/groupBy naming), the generated client returns
+ * rows keyed by DB column names and accepts DB column names in
+ * `where`/`orderBy`/`select` with no code path aware of the difference.
+ *
+ * Deliberately left untouched (the flag is literally about column names):
+ *   - `name`, `allColumns`, `dateColumns`, `dialectTypes`, `pgTypes`,
+ *     `primaryKey`, `uniqueColumns`, `indexes`, `checks`, `isView` (all already
+ *     keyed by snake_case column names);
+ *   - `relations` (relation PROPERTY names are synthetic introspection names
+ *     with no DB column equivalent, and `foreignKey`/`referenceKey`/`through`
+ *     already hold DB column names);
+ *   - entity type names, table accessors, and `enums`.
+ *
+ * Every non-PII field of each {@link ColumnMetadata} (`pii`, `pgType`,
+ * `dialectType`, `nullable`, …) is preserved. Exported from the package root so
+ * runtime-introspection and serverless users can apply the same identity mapping
+ * to a schema they build at runtime, e.g. `turbineHttp(pool,
+ * withDbFieldNames(schema))`.
+ */
+export declare function withDbFieldNames(schema: SchemaMetadata): SchemaMetadata;
+/**
+ * A typed name map from a Prisma schema onto a Turbine client, produced by
+ * `turbine migrate-from-prisma` (`generatePrismaMap` writes it as a
+ * `prisma-map.ts` module next to the generated client). It is library-side so
+ * the phase-2 `turbine-orm/prisma-compat` runtime adapter can consume the same
+ * shape to translate Prisma model/field/relation/compound-unique names onto the
+ * Turbine surface without re-parsing anything.
+ *
+ * Every name it carries was RESOLVED against live introspected metadata: a model
+ * or field that could not be matched is omitted from the map and listed in the
+ * migration report instead, so the map only ever contains verified mappings.
+ */
+export interface PrismaCompatMap {
+    /** Prisma model name → its resolved mapping. */
+    models: Record<string, PrismaModelMap>;
+    /** Prisma enum name → resolved database enum-type name. */
+    enums: Record<string, string>;
+}
+/** One Prisma model's resolved mapping onto a Turbine table + client accessor. */
+export interface PrismaModelMap {
+    /** Resolved snake_case database table name. */
+    table: string;
+    /** camelCase `TurbineClient` accessor (`db.<accessor>`). */
+    accessor: string;
+    /** Prisma field name → Turbine field name (camelCase). Relation fields excluded. */
+    fields: Record<string, string>;
+    /** Prisma relation-field name → resolved Turbine relation + cardinality. */
+    relations: Record<string, PrismaRelationMap>;
+    /**
+     * Prisma compound-unique/compound-id selector name → the Turbine field names
+     * (in declared order). The selector name is Prisma's: the explicit
+     * `@@unique(name:)` / `@@id(name:)` argument, else the field names joined with
+     * `_`. Consumed by the phase-2 client to translate
+     * `where: { <selector>: { ... } }`, including custom `@@unique(name:)` names
+     * the core `findUnique`-family derivation cannot know.
+     */
+    compoundUniques: Record<string, string[]>;
+}
+/** A resolved Prisma relation field → Turbine relation. */
+export interface PrismaRelationMap {
+    /** Turbine relation name (the `with` clause key). */
+    name: string;
+    /** `'one'` (to-one) or `'many'` (to-many, including m2m). */
+    cardinality: 'one' | 'many';
+}

package/dist/schema.js

@@ -146,3 +146,49 @@ export function singularize(s) {
         return s.slice(0, -1);
     return s;
 }
+// ---------------------------------------------------------------------------
+// keepColumnNames transform (F4)
+// ---------------------------------------------------------------------------
+/**
+ * Return a copy of `schema` in which every column's TypeScript **field** name is
+ * the raw database column name (snake_case) instead of the camelCased default,
+ * i.e. `user_id` stays `user_id` rather than becoming `userId`.
+ *
+ * This is a PURE, generate-time transform with ZERO runtime changes: it only
+ * rewrites `column.field` and rebuilds each table's `columnMap` /
+ * `reverseColumnMap` as IDENTITY maps (`user_id → user_id`). Because every
+ * runtime surface resolves column names through those maps (`toColumn`,
+ * `parseRow`, relation `json_build_object` keys, batched-loader stitching,
+ * positional decoding, aggregate/groupBy naming), the generated client returns
+ * rows keyed by DB column names and accepts DB column names in
+ * `where`/`orderBy`/`select` with no code path aware of the difference.
+ *
+ * Deliberately left untouched (the flag is literally about column names):
+ *   - `name`, `allColumns`, `dateColumns`, `dialectTypes`, `pgTypes`,
+ *     `primaryKey`, `uniqueColumns`, `indexes`, `checks`, `isView` (all already
+ *     keyed by snake_case column names);
+ *   - `relations` (relation PROPERTY names are synthetic introspection names
+ *     with no DB column equivalent, and `foreignKey`/`referenceKey`/`through`
+ *     already hold DB column names);
+ *   - entity type names, table accessors, and `enums`.
+ *
+ * Every non-PII field of each {@link ColumnMetadata} (`pii`, `pgType`,
+ * `dialectType`, `nullable`, …) is preserved. Exported from the package root so
+ * runtime-introspection and serverless users can apply the same identity mapping
+ * to a schema they build at runtime, e.g. `turbineHttp(pool,
+ * withDbFieldNames(schema))`.
+ */
+export function withDbFieldNames(schema) {
+    const tables = {};
+    for (const [tableKey, table] of Object.entries(schema.tables)) {
+        const columns = table.columns.map((col) => ({ ...col, field: col.name }));
+        const columnMap = {};
+        const reverseColumnMap = {};
+        for (const col of columns) {
+            columnMap[col.name] = col.name;
+            reverseColumnMap[col.name] = col.name;
+        }
+        tables[tableKey] = { ...table, columns, columnMap, reverseColumnMap };
+    }
+    return { ...schema, tables };
+}

package/dist/sqlite.js

@@ -49,7 +49,7 @@ import { createRequire } from 'node:module';
 import { TurbineClient } from './client.js';
 import { postgresDialect, } from './dialect.js';
 import { ConnectionError } from './errors.js';
-import { deriveEngineRelations } from './introspect.js';
+import { applyTableFilters, deriveEngineRelations } from './introspect.js';
 import { isDateType, snakeToCamel, } from './schema.js';
 let cachedDatabaseSync;
 /**
@@ -550,15 +550,10 @@ function pragma(db, sql) {
  */
 export function introspectSqliteDatabase(db, options = {}) {
     // ----- Tables (skip SQLite internal + the migration tracking table) -----
-    let tableNames = pragma(db, "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name").map((r) => r.name);
-    if (options.include?.length) {
-        const inc = new Set(options.include);
-        tableNames = tableNames.filter((t) => inc.has(t));
-    }
-    if (options.exclude?.length) {
-        const exc = new Set(options.exclude);
-        tableNames = tableNames.filter((t) => !exc.has(t));
-    }
+    const candidateTables = pragma(db, "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name").map((r) => r.name);
+    // include / exclude + default bookkeeping-table exclusions (F12), shared with
+    // every other introspector via applyTableFilters.
+    const tableNames = applyTableFilters(candidateTables, options);
     const tableSet = new Set(tableNames);
     const columnsByTable = new Map();
     const pkByTable = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.40.1",
+  "version": "0.41.0",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "exports": {
@@ -14,6 +14,11 @@
       "import": "./dist/serverless.js",
       "require": "./dist/cjs/serverless.js"
     },
+    "./prisma-compat": {
+      "types": "./dist/prisma-compat.d.ts",
+      "import": "./dist/prisma-compat.js",
+      "require": "./dist/cjs/prisma-compat.js"
+    },
     "./sqlite": {
       "types": "./dist/sqlite.d.ts",
       "import": "./dist/sqlite.js",