turbine-orm 0.41.0 → 0.42.0

package/dist/cjs/cli/index.js

@@ -1078,11 +1078,12 @@ async function cmdMigrateFromPrisma(args, config) {
     (0, ui_js_1.label)('Enums', String(ast.enums.length));
     // Resolve against the live database, unless --no-db (parse-only).
     let schemaMeta = null;
+    let url;
     if (args.noDb) {
         (0, ui_js_1.info)('Parse-only mode (--no-db): names will not be resolved.');
     }
     else {
-        const url = requireUrl(config);
+        url = requireUrl(config);
         (0, ui_js_1.label)('Database', (0, ui_js_1.redactUrl)(url));
         const spinner = new ui_js_1.Spinner('Introspecting database schema').start();
         schemaMeta = await (0, introspect_js_1.introspect)({
@@ -1098,7 +1099,10 @@ async function cmdMigrateFromPrisma(args, config) {
         spinner.succeed(`Introspected ${(0, ui_js_1.bold)(String(Object.keys(schemaMeta.tables).length))} tables`);
     }
     (0, ui_js_1.newline)();
-    const result = (0, prisma_resolve_js_1.resolvePrismaSchema)(ast, schemaMeta);
+    // `--keep-column-names` makes the generated client key fields by raw DB column
+    // names; resolve the name map against the same transformed schema so the
+    // emitted PRISMA_MAP field values agree with the client (D).
+    const result = (0, prisma_resolve_js_1.resolvePrismaSchema)(ast, schemaMeta, { keepColumnNames: config.keepColumnNames });
     // Console summary.
     (0, ui_js_1.header)('Resolution');
     for (const line of (0, prisma_report_js_1.summaryLines)(result)) {
@@ -1118,10 +1122,26 @@ async function cmdMigrateFromPrisma(args, config) {
     const reportPath = (0, node_path_1.join)(outDir, 'prisma-migration-report.md');
     (0, node_fs_1.writeFileSync)(reportPath, (0, prisma_report_js_1.formatPrismaReport)(result, { schemaPath: prismaPath, noTimestamp: args.noTimestamp }), 'utf-8');
     console.log(`  ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.cyan)(reportPath)} ${(0, ui_js_1.dim)('(report)')}`);
-    if (!args.noDb) {
+    if (!args.noDb && schemaMeta) {
         const mapPath = (0, node_path_1.join)(outDir, 'prisma-map.ts');
         (0, node_fs_1.writeFileSync)(mapPath, (0, generate_js_1.generatePrismaMap)(result.map, { noTimestamp: args.noTimestamp }), 'utf-8');
         console.log(`  ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.cyan)(mapPath)} ${(0, ui_js_1.dim)('(typed name map)')}`);
+        // Always emit the standard generated client alongside the report + name map.
+        // It is built from the live introspected metadata, so unresolved Prisma
+        // items never block it; a partially resolved run (--allow-partial) still
+        // gets a working client (C). `--keep-column-names` flows through so the
+        // client's field names match the name map (D).
+        const gen = (0, generate_js_1.generate)({
+            schema: schemaMeta,
+            outDir: config.out,
+            connectionString: url,
+            noTimestamp: args.noTimestamp,
+            importExtension: config.importExtension,
+            keepColumnNames: config.keepColumnNames,
+        });
+        for (const file of gen.files) {
+            console.log(`  ${(0, ui_js_1.dim)(ui_js_1.symbols.teeEnd)} ${(0, ui_js_1.cyan)((0, node_path_1.join)(outDir, file))} ${(0, ui_js_1.dim)('(client)')}`);
+        }
     }
     (0, ui_js_1.newline)();
     // Exit non-zero when anything is UNRESOLVED, unless --allow-partial.

package/dist/cjs/cli/prisma-resolve.js

@@ -75,16 +75,18 @@ function fieldColumn(model, fieldName) {
 function isRelationField(typeName, modelNames) {
     return modelNames.has(typeName);
 }
-// ---------------------------------------------------------------------------
-// Main entry
-// ---------------------------------------------------------------------------
 /**
  * Resolve `ast` against introspected `schema` (or `null` for parse-only).
  */
-function resolvePrismaSchema(ast, schema) {
-    const noDb = schema === null;
+function resolvePrismaSchema(ast, schema, options = {}) {
+    // Under keep-column-names the generated client keys fields by raw DB column
+    // names; resolve against the same transformed metadata so the name map's
+    // field values match the client (D).
+    const resolvedSchema = schema && options.keepColumnNames ? (0, schema_js_1.withDbFieldNames)(schema) : schema;
+    const noDb = resolvedSchema === null;
     const modelNames = new Set(ast.models.map((m) => m.name));
-    const tableNames = schema ? new Set(Object.keys(schema.tables)) : new Set();
+    const modelsByName = new Map(ast.models.map((m) => [m.name, m]));
+    const tableNames = resolvedSchema ? new Set(Object.keys(resolvedSchema.tables)) : new Set();
     // Pass 1 - resolve each model to a table so relation targets are known.
     const modelTable = new Map();
     for (const model of ast.models) {
@@ -102,7 +104,7 @@ function resolvePrismaSchema(ast, schema) {
     for (const model of ast.models) {
         const rt = modelTable.get(model.name);
         const table = rt.table;
-        const tableMeta = table && schema ? schema.tables[table] : undefined;
+        const tableMeta = table && resolvedSchema ? resolvedSchema.tables[table] : undefined;
         const accessor = table ? (0, schema_js_1.snakeToCamel)(table) : null;
         const status = noDb ? 'parsed' : table ? 'resolved' : 'unresolved';
         const resolved = {
@@ -119,7 +121,7 @@ function resolvePrismaSchema(ast, schema) {
         };
         for (const field of model.fields) {
             if (isRelationField(field.type, modelNames)) {
-                resolved.relations.push(resolveRelation(model, field.name, field.type, field.isList, modelTable, schema, tableMeta, noDb));
+                resolved.relations.push(resolveRelation(model, field.name, field.type, field.isList, modelTable, modelsByName, resolvedSchema, tableMeta, noDb));
             }
             else {
                 resolved.fields.push(resolveScalarField(model, field.name, tableMeta, noDb));
@@ -156,7 +158,7 @@ function resolvePrismaSchema(ast, schema) {
     }
     // Enums.
     for (const en of ast.enums) {
-        const r = resolveEnum(en.name, en.map, schema, noDb);
+        const r = resolveEnum(en.name, en.map, resolvedSchema, noDb);
         result.enums.push(r);
         if (!noDb && r.status === 'resolved' && r.turbineName)
             result.map.enums[en.name] = r.turbineName;
@@ -213,7 +215,28 @@ function resolveScalarField(model, fieldName, tableMeta, noDb) {
         reason: `column "${column}" not found on table "${tableMeta.name}"`,
     };
 }
-function resolveRelation(model, fieldName, targetModelName, isList, modelTable, schema, tableMeta, noDb) {
+/**
+ * The `@relation("Name")` name on a field, from the `name:` argument or the
+ * first positional string argument. Absent when the field has no `@relation`
+ * attribute or the attribute carries no name.
+ */
+function relationNameOf(field) {
+    const relAttr = field?.attrs.find((a) => a.name === 'relation');
+    if (!relAttr)
+        return undefined;
+    const named = relAttr.args.find((a) => a.key === 'name' && a.kind === 'string');
+    if (named?.value)
+        return named.value;
+    const positional = relAttr.args.find((a) => a.key === undefined && a.kind === 'string');
+    return positional?.value;
+}
+/** The FK column list a field pins via `@relation(fields: [...])`, resolved to columns. */
+function relationFkColumns(model, field) {
+    const relAttr = field?.attrs.find((a) => a.name === 'relation');
+    const fieldsArg = relAttr?.args.find((a) => a.key === 'fields' && a.kind === 'array');
+    return fieldsArg?.items?.map((pf) => fieldColumn(model, pf)) ?? null;
+}
+function resolveRelation(model, fieldName, targetModelName, isList, modelTable, modelsByName, schema, tableMeta, noDb) {
     const cardinality = isList ? 'many' : 'one';
     const base = {
         prismaName: fieldName,
@@ -230,9 +253,24 @@ function resolveRelation(model, fieldName, targetModelName, isList, modelTable,
     const targetTable = modelTable.get(targetModelName)?.table ?? null;
     // Explicit @relation(fields: [...]) names the FK columns on THIS side.
     const field = model.fields.find((f) => f.name === fieldName);
-    const relAttr = field?.attrs.find((a) => a.name === 'relation');
-    const fieldsArg = relAttr?.args.find((a) => a.key === 'fields' && a.kind === 'array');
-    const fkColumns = fieldsArg?.items?.map((pf) => fieldColumn(model, pf)) ?? null;
+    let fkColumns = relationFkColumns(model, field);
+    // Inverse side (no fields on this side) with a @relation("Name"): pair by that
+    // name FIRST. Find the opposing model's field carrying the same relation name
+    // AND the FK (fields: [...]), and resolve through ITS foreign key. This is how
+    // Prisma disambiguates two or more relations to the same target model. Only
+    // fall back to the ambiguity handling below when there is no relation name or
+    // the named pair cannot be found.
+    if (!fkColumns || fkColumns.length === 0) {
+        const relName = relationNameOf(field);
+        const targetModel = modelsByName.get(targetModelName);
+        if (relName && targetModel) {
+            const opposing = targetModel.fields.find((f) => f.type === model.name &&
+                relationNameOf(f) === relName &&
+                (relationFkColumns(targetModel, f)?.length ?? 0) > 0);
+            if (opposing)
+                fkColumns = relationFkColumns(targetModel, opposing);
+        }
+    }
     const candidates = Object.values(tableMeta.relations).filter((def) => {
         if (targetTable && def.to !== targetTable)
             return false;
@@ -293,10 +331,25 @@ function resolveCompoundUnique(model, key, tableMeta, noDb) {
             return { ...base, turbineFields, status: 'resolved' };
         return { ...base, reason: `no compound primary key on "${tableMeta.name}" matches (${columns.join(', ')})` };
     }
-    // Introspected metadata carries composite unique constraints in uniqueColumns.
-    if (matches(tableMeta.uniqueColumns))
+    // A composite unique can surface EITHER as a unique constraint (uniqueColumns)
+    // OR as a plain UNIQUE INDEX (Prisma creates unique indexes, not table
+    // constraints), so accept a matching unique index too. A partial unique index
+    // does not enforce uniqueness across the whole table, so it never satisfies a
+    // @@unique; skip it defensively (the marker may be added to IndexMetadata).
+    const uniqueIndexMatches = tableMeta.indexes.some((idx) => {
+        if (!idx.unique)
+            return false;
+        if (idx.partial)
+            return false;
+        return [...idx.columns].sort().join(',') === want;
+    });
+    if (matches(tableMeta.uniqueColumns) || uniqueIndexMatches) {
         return { ...base, turbineFields, status: 'resolved' };
-    return { ...base, reason: `no unique constraint on "${tableMeta.name}" matches (${columns.join(', ')})` };
+    }
+    return {
+        ...base,
+        reason: `no unique constraint or unique index on "${tableMeta.name}" matches (${columns.join(', ')})`,
+    };
 }
 function resolveEnum(name, map, schema, noDb) {
     if (noDb || !schema)

package/dist/cjs/generate.js

@@ -460,13 +460,23 @@ function generateTypes(schema, options) {
             for (const uc of table.uniqueColumns)
                 addCompound(uc);
             for (const idx of table.indexes) {
-                if (idx.unique && !idx.docPath)
+                // A partial unique index does not guarantee table-wide row uniqueness,
+                // so it must not become a compound-unique selector (matches the runtime
+                // exclusion in query/compound-unique.ts).
+                if (idx.unique && !idx.docPath && !idx.partial)
                     addCompound(idx.columns);
             }
             const selectorEntries = compoundSets.map((cols) => {
                 const members = cols.map(memberType);
                 return {
-                    selectorName: members.map((m) => m.field).join('_'),
+                    // The selector NAME is the underscore-join of the member FIELD names.
+                    // It is normally a valid identifier (`orgId_userId`), but a
+                    // junction-style column that is not a valid identifier (e.g. a quoted
+                    // uppercase `"A"` / `"B"`) would join into a broken object key. Emit
+                    // any non-identifier name as ONE quoted string-literal key so the
+                    // generated types.ts always parses; the runtime selector map in
+                    // query/compound-unique.ts registers the same name spelling.
+                    selectorName: quoteIfNeeded(members.map((m) => m.field).join('_')),
                     memberType: `{ ${members.map((m) => `${quoteIfNeeded(m.field)}: ${m.tsType}`).join('; ')} }`,
                 };
             });
@@ -725,7 +735,11 @@ function generateMetadata(schema, options) {
         // indexes
         lines.push('      indexes: [');
         for (const idx of table.indexes) {
-            lines.push(`        { name: '${escSQ(idx.name)}', columns: [${idx.columns.map((c) => `'${escSQ(c)}'`).join(', ')}], unique: ${idx.unique}, definition: ${JSON.stringify(idx.definition)} },`);
+            // `partial` must round-trip: the runtime compound-unique derivation reads
+            // the GENERATED metadata, so dropping the flag here would re-arm a
+            // partial-unique selector that types.ts correctly excludes.
+            const partialSeg = idx.partial ? ', partial: true' : '';
+            lines.push(`        { name: '${escSQ(idx.name)}', columns: [${idx.columns.map((c) => `'${escSQ(c)}'`).join(', ')}], unique: ${idx.unique}${partialSeg}, definition: ${JSON.stringify(idx.definition)} },`);
         }
         lines.push('      ],');
         // checks: introspected named CHECK constraints. Emitted only when present

package/dist/cjs/introspect.js

@@ -18,6 +18,8 @@ exports.applyTableFilters = applyTableFilters;
 exports.defaultExcludedTablesPresent = defaultExcludedTablesPresent;
 exports.introspect = introspect;
 exports.introspectPostgresCatalog = introspectPostgresCatalog;
+exports.parseIndexColumns = parseIndexColumns;
+exports.indexHasWhere = indexHasWhere;
 exports.stripCheckWrapper = stripCheckWrapper;
 exports.relationNameFromColumn = relationNameFromColumn;
 exports.isUnknownTsType = isUnknownTsType;
@@ -414,15 +416,15 @@ async function introspectPostgresCatalog(options) {
                 continue;
             if (!indexesByTable.has(row.tablename))
                 indexesByTable.set(row.tablename, []);
-            const isUnique = row.indexdef.includes('UNIQUE');
-            // Extract column names from indexdef (e.g. "CREATE INDEX idx ON tbl USING btree (col1, col2)")
-            const colMatch = row.indexdef.match(/\((.+)\)/);
-            const columns = colMatch ? colMatch[1].split(',').map((c) => c.trim().replace(/ (ASC|DESC)/i, '')) : [];
+            const indexdef = row.indexdef;
+            const isUnique = indexdef.includes('UNIQUE');
+            const isPartial = indexHasWhere(indexdef);
             indexesByTable.get(row.tablename).push({
                 name: row.indexname,
-                columns,
+                columns: parseIndexColumns(indexdef),
                 unique: isUnique,
-                definition: row.indexdef,
+                definition: indexdef,
+                ...(isPartial ? { partial: true } : {}),
             });
         }
         // ----- Group check constraints by table -----
@@ -511,7 +513,17 @@ async function introspectPostgresCatalog(options) {
         // hasMany relations derived from J's FKs are left untouched — this block
         // never removes or renames anything. Naming/collision handling lives in the
         // shared addAutoManyToManyRelations helper.
-        addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, new Map(Array.from(columnsByTable, ([tbl, cols]) => [tbl, cols.map((c) => c.name)])), relationsByTable, columnFieldsByTable, unknownTypedFieldsByTable);
+        //
+        // Prisma's implicit m2m junctions have no primary key (just a two-column
+        // UNIQUE index over the FK columns), so pass the introspected two-column
+        // unique indexes as the fallback junction-key source.
+        const uniqueIndexColsByTable = new Map();
+        for (const [tbl, idxs] of indexesByTable) {
+            const twoColUniques = idxs.filter((idx) => idx.unique && idx.columns.length === 2).map((idx) => idx.columns);
+            if (twoColUniques.length > 0)
+                uniqueIndexColsByTable.set(tbl, twoColUniques);
+        }
+        addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, new Map(Array.from(columnsByTable, ([tbl, cols]) => [tbl, cols.map((c) => c.name)])), relationsByTable, columnFieldsByTable, unknownTypedFieldsByTable, uniqueIndexColsByTable);
         // ----- Assemble TableMetadata for each table -----
         const tables = {};
         for (const tableName of tableNames) {
@@ -556,6 +568,50 @@ async function introspectPostgresCatalog(options) {
         await pool.end();
     }
 }
+/**
+ * Parse the indexed column names out of a `pg_indexes.indexdef` string.
+ *
+ * `indexdef` always reads `CREATE [UNIQUE] INDEX name ON tbl USING method
+ * (col, ...) [WHERE predicate]`. We anchor on the `USING` clause's parenthesised
+ * column list (the same precedent as `describeIndexDefMismatch` in
+ * schema-sql.ts) so a PARTIAL index's trailing `WHERE (...)` parentheses are
+ * never mistaken for the column list. The older greedy `/\((.+)\)/` swallowed
+ * `) WHERE (` and spliced a raw predicate fragment into the column names, which
+ * then leaked into generated compound-unique selector names.
+ *
+ * Each column is de-quoted (Postgres quotes non-lowercase identifiers such as a
+ * Prisma implicit m2m junction's `"A"` / `"B"`), so the names match the
+ * unquoted column names carried elsewhere in the metadata. Expression columns
+ * (anything containing a parenthesis) are dropped conservatively: a functional
+ * index does not name a plain column.
+ */
+function parseIndexColumns(indexdef) {
+    const m = indexdef.match(/USING\s+\w+\s*\(([^)]*)\)/i) ?? indexdef.match(/\(([^)]*)\)/);
+    if (!m)
+        return [];
+    return m[1]
+        .split(',')
+        .map((c) => unquoteIndexIdent(c
+        .trim()
+        .replace(/\s+(ASC|DESC)$/i, '')
+        .trim()))
+        .filter((c) => c.length > 0 && !c.includes('(') && !c.includes(')'));
+}
+/** Strip one pair of surrounding double quotes and unescape doubled `""`. */
+function unquoteIndexIdent(col) {
+    if (col.length >= 2 && col.startsWith('"') && col.endsWith('"')) {
+        return col.slice(1, -1).replace(/""/g, '"');
+    }
+    return col;
+}
+/**
+ * Whether an `indexdef` carries a top-level `WHERE` predicate (a PARTIAL index).
+ * pg_indexes only ever emits `WHERE` as the partial predicate, so a keyword
+ * match is sufficient (matches the `describeIndexDefMismatch` precedent).
+ */
+function indexHasWhere(indexdef) {
+    return /\bWHERE\b/i.test(indexdef);
+}
 /**
  * Recover the raw check expression from `pg_get_constraintdef` output, which
  * wraps it as `CHECK ((expr))`. Strips the leading `CHECK ` keyword and one
@@ -900,11 +956,15 @@ function buildRelationsFromForeignKeys(foreignKeys, columnFieldsByTable, fkActio
  * IDENTICAL relation names for the same logical schema.
  *
  * A table J is a PURE junction only when ALL of these hold:
- *   1. J's primary key is exactly two columns.
+ *   1. J's junction KEY is exactly two columns: either a two-column primary
+ *      key, OR (Prisma implicit m2m junctions have NO primary key) a two-column
+ *      UNIQUE index over exactly the two FK columns, supplied via the optional
+ *      `uniqueIndexColsByTable`. When that map is absent the behavior is
+ *      unchanged: only a two-column PK qualifies.
  *   2. J has exactly two FKs, each single-column.
- *   3. Each FK's source column is one of J's two PK columns.
+ *   3. Each FK's source column is one of J's two key columns.
  *   4. The two FKs target two DISTINCT tables (A and B).
- *   5. J has no payload columns beyond the two FK/PK columns.
+ *   5. J has no payload columns beyond the two FK/key columns.
  *
  * For such a J linking A and B this ADDS a `manyToMany` on A → B and B → A
  * routed `through` J. It never removes or renames an existing relation:
@@ -915,11 +975,8 @@ function buildRelationsFromForeignKeys(foreignKeys, columnFieldsByTable, fkActio
  *   - a shadowed concrete-typed column → deterministic `Rel` suffix + warn
  *     instead of silently dropping the relation.
  */
-function addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, columnNamesByTable, relationsByTable, columnFieldsByTable, unknownTypedFieldsByTable) {
+function addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, columnNamesByTable, relationsByTable, columnFieldsByTable, unknownTypedFieldsByTable, uniqueIndexColsByTable) {
     for (const tableName of tableNames) {
-        const pk = pkByTable.get(tableName) ?? [];
-        if (pk.length !== 2)
-            continue;
         // FKs whose source is this table — both must be single-column.
         const tableFks = foreignKeys.filter((fk) => fk.sourceTable === tableName);
         if (tableFks.length !== 2)
@@ -927,20 +984,35 @@ function addAutoManyToManyRelations(tableNames, foreignKeys, pkByTable, columnNa
         if (tableFks.some((fk) => fk.sourceColumns.length !== 1))
             continue;
         const fkCols = tableFks.map((fk) => fk.sourceColumns[0]);
-        const pkSet = new Set(pk);
-        // Both FK columns must be the PK columns (and vice-versa).
-        if (!fkCols.every((c) => pkSet.has(c)))
-            continue;
         if (new Set(fkCols).size !== 2)
             continue;
+        const fkSet = new Set(fkCols);
+        // The junction KEY is normally the two-column PK. Prisma's implicit m2m
+        // junctions have NO primary key, so accept instead a two-column UNIQUE
+        // index that covers exactly the two FK columns. Only a PK-less table is
+        // eligible for the unique-index fallback, so a real entity that happens to
+        // carry a two-column unique index is never mistaken for a junction.
+        const pk = pkByTable.get(tableName) ?? [];
+        let keyCols;
+        if (pk.length === 2 && pk.every((c) => fkSet.has(c))) {
+            keyCols = pk;
+        }
+        else if (pk.length === 0) {
+            const uniques = uniqueIndexColsByTable?.get(tableName) ?? [];
+            keyCols = uniques.find((u) => u.length === 2 && u.every((c) => fkSet.has(c)));
+        }
+        if (!keyCols)
+            continue;
         // Two DISTINCT target tables.
         const [fkA, fkB] = tableFks;
         if (fkA.targetTable === fkB.targetTable)
             continue;
-        // No payload columns: J's columns are exactly the two FK/PK columns.
+        // No payload columns: J's columns are exactly the two FK/key columns.
         const jCols = columnNamesByTable.get(tableName) ?? [];
         if (jCols.length !== 2)
             continue;
+        if (!jCols.every((c) => fkSet.has(c)))
+            continue;
         // For each direction, the m2m `referenceKey` is the *targeted* table's
         // referenced column(s); the junction's sourceKey is the FK column pointing
         // to that table; the targetKey is the FK column pointing to the OTHER table.

package/dist/cjs/prisma-compat.js

@@ -848,14 +848,28 @@ function prismaPropertyAlias(model) {
  */
 function makeDelegate(ctx, mm, getQI) {
     const pe = ctx.options.prismaErrorCodes;
-    const lift = (run, batchable) => new CompatPromise(async () => {
-        try {
-            return await run();
-        }
-        catch (err) {
-            throw decorate(err, pe);
-        }
-    }, batchable);
+    // Build a lazy Prisma-style promise for one delegate call. Crucially, the
+    // Prisma-arg `translate` step runs INSIDE the deferred paths (the run closure
+    // and the batchable build closure), never eagerly at call time: a
+    // translation/validation error (unknown relation in `include`, unknown
+    // compound selector, negative take, ...) must surface as a REJECTED promise
+    // so a Prisma-shaped `.catch()` fires, not as a synchronous throw. The
+    // async run wrapper also converts any synchronous throw from the underlying
+    // `qi.*` build into a rejection; the array `$transaction([...])` batch path
+    // catches the same throw from `batch.build`.
+    const defer = (translate, run, batch) => {
+        const batchable = batch
+            ? { build: () => batch.build(getQI(), translate()), reshape: batch.reshape }
+            : undefined;
+        return new CompatPromise(async () => {
+            try {
+                return await run(getQI(), translate());
+            }
+            catch (err) {
+                throw decorate(err, pe);
+            }
+        }, batchable);
+    };
     const requireWhere = (args, op) => {
         if (!args || args.where === undefined) {
             throw new errors_js_1.ValidationError(`[turbine] prisma-compat: ${op} on "${modelName(ctx, mm)}" requires a \`where\`.`);
@@ -863,125 +877,68 @@ function makeDelegate(ctx, mm, getQI) {
         return args;
     };
     return {
-        findMany: (args = {}) => {
-            const t = translateReadArgs(ctx, mm, args);
-            return lift(() => getQI()
-                .findMany(t)
-                .then((r) => reshapeRows(ctx, mm, r)), { build: () => getQI().buildFindMany(t), reshape: (raw) => reshapeRows(ctx, mm, raw) });
-        },
-        findFirst: (args = {}) => {
-            const t = translateReadArgs(ctx, mm, args);
-            return lift(() => getQI()
-                .findFirst(t)
-                .then((r) => reshapeRowOrNull(ctx, mm, r)), { build: () => getQI().buildFindFirst(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) });
-        },
-        findUnique: (args) => {
-            const t = translateReadArgs(ctx, mm, requireWhere(args, 'findUnique'));
-            return lift(() => getQI()
-                .findUnique(t)
-                .then((r) => reshapeRowOrNull(ctx, mm, r)), { build: () => getQI().buildFindUnique(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) });
-        },
-        findFirstOrThrow: (args = {}) => {
-            const t = translateReadArgs(ctx, mm, args);
-            return lift(() => getQI()
-                .findFirstOrThrow(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildFindFirstOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        findUniqueOrThrow: (args) => {
-            const t = translateReadArgs(ctx, mm, requireWhere(args, 'findUniqueOrThrow'));
-            return lift(() => getQI()
-                .findUniqueOrThrow(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildFindUniqueOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        create: (args) => {
+        findMany: (args = {}) => defer(() => translateReadArgs(ctx, mm, args), (qi, t) => qi.findMany(t).then((r) => reshapeRows(ctx, mm, r)), { build: (qi, t) => qi.buildFindMany(t), reshape: (raw) => reshapeRows(ctx, mm, raw) }),
+        findFirst: (args = {}) => defer(() => translateReadArgs(ctx, mm, args), (qi, t) => qi.findFirst(t).then((r) => reshapeRowOrNull(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirst(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) }),
+        findUnique: (args) => defer(() => translateReadArgs(ctx, mm, requireWhere(args, 'findUnique')), (qi, t) => qi.findUnique(t).then((r) => reshapeRowOrNull(ctx, mm, r)), { build: (qi, t) => qi.buildFindUnique(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) }),
+        findFirstOrThrow: (args = {}) => defer(() => translateReadArgs(ctx, mm, args), (qi, t) => qi.findFirstOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirstOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        findUniqueOrThrow: (args) => defer(() => translateReadArgs(ctx, mm, requireWhere(args, 'findUniqueOrThrow')), (qi, t) => qi.findUniqueOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindUniqueOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        create: (args) => defer(() => {
             const t = { data: translateWriteData(ctx, mm, args.data) };
             if (typeof args.timeout === 'number')
                 t.timeout = args.timeout;
-            return lift(() => getQI()
-                .create(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildCreate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        createMany: (args) => {
+            return t;
+        }, (qi, t) => qi.create(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildCreate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        createMany: (args) => defer(() => {
             const data = args.data;
             const rows = Array.isArray(data) ? data.map((d) => translateWriteData(ctx, mm, d)) : [];
             const t = { data: rows };
             if (args.skipDuplicates)
                 t.skipDuplicates = true;
-            return lift(() => getQI()
-                .createMany(t)
-                .then((r) => ({ count: r.length })), { build: () => getQI().buildCreateMany(t), reshape: (raw) => ({ count: raw.length }) });
-        },
-        update: (args) => {
+            return t;
+        }, (qi, t) => qi.createMany(t).then((r) => ({ count: r.length })), { build: (qi, t) => qi.buildCreateMany(t), reshape: (raw) => ({ count: raw.length }) }),
+        update: (args) => defer(() => {
             const a = requireWhere(args, 'update');
-            const t = { where: translateWhere(ctx, mm, a.where), data: translateWriteData(ctx, mm, a.data) };
-            return lift(() => getQI()
-                .update(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildUpdate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        updateMany: (args) => {
+            return { where: translateWhere(ctx, mm, a.where), data: translateWriteData(ctx, mm, a.data) };
+        }, (qi, t) => qi.update(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildUpdate(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        updateMany: (args) => defer(() => {
             const a = args;
             const t = { where: translateWhere(ctx, mm, a.where ?? {}), data: translateWriteData(ctx, mm, a.data) };
             if (a.where === undefined)
                 t.allowFullTableScan = true;
-            return lift(() => getQI().updateMany(t), {
-                build: () => getQI().buildUpdateMany(t),
-                reshape: (raw) => raw,
-            });
-        },
-        delete: (args) => {
+            return t;
+        }, (qi, t) => qi.updateMany(t), { build: (qi, t) => qi.buildUpdateMany(t), reshape: (raw) => raw }),
+        delete: (args) => defer(() => {
             const a = requireWhere(args, 'delete');
-            const t = { where: translateWhere(ctx, mm, a.where) };
-            return lift(() => getQI()
-                .delete(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildDelete(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        deleteMany: (args = {}) => {
+            return { where: translateWhere(ctx, mm, a.where) };
+        }, (qi, t) => qi.delete(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildDelete(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        deleteMany: (args = {}) => defer(() => {
             const a = args;
             const t = { where: translateWhere(ctx, mm, a.where ?? {}) };
             if (a.where === undefined)
                 t.allowFullTableScan = true;
-            return lift(() => getQI().deleteMany(t), {
-                build: () => getQI().buildDeleteMany(t),
-                reshape: (raw) => raw,
-            });
-        },
-        upsert: (args) => {
+            return t;
+        }, (qi, t) => qi.deleteMany(t), { build: (qi, t) => qi.buildDeleteMany(t), reshape: (raw) => raw }),
+        upsert: (args) => defer(() => {
             const a = requireWhere(args, 'upsert');
-            const t = {
+            return {
                 where: translateWhere(ctx, mm, a.where),
                 create: translateWriteData(ctx, mm, a.create),
                 update: translateWriteData(ctx, mm, a.update),
             };
-            return lift(() => getQI()
-                .upsert(t)
-                .then((r) => reshapeRow(ctx, mm, r)), { build: () => getQI().buildUpsert(t), reshape: (raw) => reshapeRow(ctx, mm, raw) });
-        },
-        count: (args = {}) => {
+        }, (qi, t) => qi.upsert(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildUpsert(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        count: (args = {}) => defer(() => {
             const t = {};
             if (args.where !== undefined)
                 t.where = translateWhere(ctx, mm, args.where);
             if (typeof args.timeout === 'number')
                 t.timeout = args.timeout;
-            return lift(() => getQI().count(t), {
-                build: () => getQI().buildCount(t),
-                reshape: (raw) => raw,
-            });
-        },
-        aggregate: (args) => {
-            const t = translateAggregateArgs(ctx, mm, args, false);
-            return lift(() => getQI()
-                .aggregate(t)
-                .then((r) => reshapeAggregate(ctx, mm, r)), { build: () => getQI().buildAggregate(t), reshape: (raw) => reshapeAggregate(ctx, mm, raw) });
-        },
-        groupBy: (args) => {
-            const t = translateAggregateArgs(ctx, mm, args, true);
-            return lift(() => getQI()
-                .groupBy(t)
-                .then((rows) => rows.map((r) => reshapeGroupRow(ctx, mm, r))), {
-                build: () => getQI().buildGroupBy(t),
-                reshape: (raw) => raw.map((r) => reshapeGroupRow(ctx, mm, r)),
-            });
-        },
+            return t;
+        }, (qi, t) => qi.count(t), { build: (qi, t) => qi.buildCount(t), reshape: (raw) => raw }),
+        aggregate: (args) => defer(() => translateAggregateArgs(ctx, mm, args, false), (qi, t) => qi.aggregate(t).then((r) => reshapeAggregate(ctx, mm, r)), { build: (qi, t) => qi.buildAggregate(t), reshape: (raw) => reshapeAggregate(ctx, mm, raw) }),
+        groupBy: (args) => defer(() => translateAggregateArgs(ctx, mm, args, true), (qi, t) => qi.groupBy(t).then((rows) => rows.map((r) => reshapeGroupRow(ctx, mm, r))), {
+            build: (qi, t) => qi.buildGroupBy(t),
+            reshape: (raw) => raw.map((r) => reshapeGroupRow(ctx, mm, r)),
+        }),
     };
 }
 function poolOf(db) {