@avytrix/nestjs-drizzle-crud 3.7.2 → 3.8.0

package/dist/core/abstract/sql-base-crud.service.js

@@ -10,7 +10,14 @@ const merge_config_1 = require("../utils/merge-config");
 const query_parser_1 = require("../utils/query-parser");
 const JOIN_KEY = "__crudJoinKey";
 const CURSOR_KEY = "__crudCursor";
+const SCOPE_MEMO = Symbol("scopeMemo");
 const ROLLBACK = Symbol("rollback");
+class DeferredDiagnosis {
+    settle;
+    constructor(settle) {
+        this.settle = settle;
+    }
+}
 const BIND_LIMITS = {
     postgresql: { limit: 65_535, name: "PostgreSQL" },
     mysql: { limit: 65_535, name: "MySQL" },
@@ -185,9 +192,25 @@ class SqlBaseCrudService {
         const scope = this.config.scope;
         if (!scope || options?.skipScope)
             return null;
+        const memo = options?.[SCOPE_MEMO];
+        if (memo && Object.hasOwn(memo, "values"))
+            return memo.values;
         const values = typeof scope === "function"
             ? scope(options?.context ?? crud_context_1.CrudContext.current() ?? {})
             : scope;
+        const checked = this.checkScope(values);
+        if (memo)
+            memo.values = checked;
+        return checked;
+    }
+    withScopeMemo(options) {
+        if (typeof this.config.scope !== "function" ||
+            options?.[SCOPE_MEMO]) {
+            return options;
+        }
+        return { ...options, [SCOPE_MEMO]: {} };
+    }
+    checkScope(values) {
         if (values === null)
             return null;
         if (!(0, merge_config_1.isPlainObject)(values)) {
@@ -422,6 +445,10 @@ class SqlBaseCrudService {
             return relation.type;
         return "belongsTo";
     }
+    relationNamed(name) {
+        const relations = this.config.relations || {};
+        return Object.hasOwn(relations, name) ? relations[name] : undefined;
+    }
     isCollection(relation) {
         return this.relationType(relation) !== "belongsTo";
     }
@@ -612,23 +639,19 @@ class SqlBaseCrudService {
         const referenced = target[referencedName];
         if (!referenced)
             return;
-        const ids = Array.from(new Set(hosts.map((host) => host[localKey]).filter((v) => v != null)));
-        if (ids.length === 0) {
-            for (const host of hosts)
-                host[node.name] = null;
+        const ids = this.loaderKeys(hosts, localKey, node);
+        if (ids.length === 0)
             return;
-        }
         const fields = this.relationProjection(target, select.base, [
             referencedName,
             ...this.keysForChildren(node.children, target),
         ]);
-        const conditions = [(0, drizzle_orm_1.inArray)(referenced, ids)];
-        conditions.push(...this.relatedRowScope(target, options));
-        const related = await (fields ? db.select(fields) : db.select())
+        const scope = this.relatedRowScope(target, options);
+        const related = await this.inChunks(db, ids, (chunk) => (fields ? db.select(fields) : db.select())
             .from(target)
-            .where((0, drizzle_orm_1.and)(...conditions));
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.inArray)(referenced, chunk), ...scope)));
         const byKey = new Map();
-        for (const row of related ?? [])
+        for (const row of related)
             byKey.set(row?.[referencedName], row);
         for (const host of hosts) {
             host[node.name] = byKey.get(host[localKey]) ?? null;
@@ -643,27 +666,43 @@ class SqlBaseCrudService {
         if (!foreign)
             return;
         const parentKey = this.parentKeyOf(node.config, hostTable);
-        const ids = Array.from(new Set(hosts.map((host) => host[parentKey]).filter((v) => v != null)));
-        if (ids.length === 0) {
-            for (const host of hosts)
-                host[node.name] = [];
+        const ids = this.loaderKeys(hosts, parentKey, node);
+        if (ids.length === 0)
             return;
-        }
         const fields = this.relationProjection(target, select.base, [
             foreignKey,
             ...this.keysForChildren(node.children, target),
         ]);
-        const conditions = [(0, drizzle_orm_1.inArray)(foreign, ids)];
-        conditions.push(...this.relatedRowScope(target, options));
-        let query = (fields ? db.select(fields) : db.select())
-            .from(target)
-            .where((0, drizzle_orm_1.and)(...conditions));
-        const orderBy = this.collectionOrderBy(node.config);
-        if (orderBy.length > 0)
-            query = query.orderBy(...orderBy);
-        const children = await query;
+        const children = await this.loadCollection(db, node, ids, options, () => fields ? db.select(fields).from(target) : db.select().from(target));
         this.groupCollection(hosts, node.name, parentKey, children, foreignKey);
     }
+    loaderKeys(hosts, key, node) {
+        const ids = Array.from(new Set(hosts.map((host) => host[key]).filter((v) => v != null)));
+        if (ids.length === 0) {
+            const collection = this.isCollection(node.config);
+            for (const host of hosts)
+                host[node.name] = collection ? [] : null;
+        }
+        return ids;
+    }
+    loadCollection(db, node, ids, options, source) {
+        const relation = node.config;
+        const key = this.relationType(relation) === "manyToMany"
+            ? relation.through[relation.throughLocalKey]
+            : relation.table[relation.foreignKey];
+        const scope = this.relatedRowScope(relation.table, options);
+        const orderBy = this.collectionOrderBy(relation);
+        return this.inChunks(db, ids, (chunk) => {
+            const query = source().where((0, drizzle_orm_1.and)((0, drizzle_orm_1.inArray)(key, chunk), ...scope));
+            return orderBy.length > 0 ? query.orderBy(...orderBy) : query;
+        });
+    }
+    selectThrough(db, fields, relation, target = relation.table, through = relation.through) {
+        return db
+            .select(fields)
+            .from(through)
+            .innerJoin(target, (0, drizzle_orm_1.eq)(through[relation.throughForeignKey], target[relation.references ?? "id"]));
+    }
     async loadManyToMany(db, hosts, node, select, hostTable = this.config.table, options) {
         const { through, throughLocalKey, throughForeignKey, references } = node.config;
         if (!through || !throughLocalKey || !throughForeignKey)
@@ -676,12 +715,9 @@ class SqlBaseCrudService {
         if (!referenced || !joinLocal || !joinForeign)
             return;
         const parentKey = this.parentKeyOf(node.config, hostTable);
-        const ids = Array.from(new Set(hosts.map((host) => host[parentKey]).filter((v) => v != null)));
-        if (ids.length === 0) {
-            for (const host of hosts)
-                host[node.name] = [];
+        const ids = this.loaderKeys(hosts, parentKey, node);
+        if (ids.length === 0)
             return;
-        }
         const columns = (0, drizzle_orm_1.getTableColumns)(target);
         const wanted = select.base.length > 0
             ? [...select.base, ...this.keysForChildren(node.children, target)]
@@ -691,19 +727,25 @@ class SqlBaseCrudService {
             if (columns[name])
                 fields[name] = columns[name];
         }
-        const conditions = [(0, drizzle_orm_1.inArray)(joinLocal, ids)];
-        conditions.push(...this.relatedRowScope(target, options));
-        let query = db
-            .select(fields)
-            .from(through)
-            .innerJoin(target, (0, drizzle_orm_1.eq)(joinForeign, referenced))
-            .where((0, drizzle_orm_1.and)(...conditions));
-        const orderBy = this.collectionOrderBy(node.config);
-        if (orderBy.length > 0)
-            query = query.orderBy(...orderBy);
-        const rows = await query;
+        const rows = await this.loadCollection(db, node, ids, options, () => this.selectThrough(db, fields, node.config));
         this.groupCollection(hosts, node.name, parentKey, rows, JOIN_KEY, true);
     }
+    relationChunkSize(db) {
+        const { limit } = this.bindLimit(db);
+        return Math.max(1, limit - Math.min(1_000, Math.floor(limit / 10)));
+    }
+    async inChunks(db, ids, query) {
+        const size = this.relationChunkSize(db);
+        if (ids.length <= size)
+            return (await query(ids)) ?? [];
+        const out = [];
+        for (let start = 0; start < ids.length; start += size) {
+            for (const row of (await query(ids.slice(start, start + size))) ?? []) {
+                out.push(row);
+            }
+        }
+        return out;
+    }
     groupCollection(hosts, name, parentKey, rows, groupBy, stripGroupKey = false) {
         const grouped = new Map();
         for (const row of rows ?? []) {
@@ -839,10 +881,7 @@ class SqlBaseCrudService {
             return { key, column, order };
         }
         const name = key.slice(0, dot);
-        const relations = this.config.relations || {};
-        const relation = Object.hasOwn(relations, name)
-            ? relations[name]
-            : undefined;
+        const relation = this.relationNamed(name);
         const column = relation
             ? this.columnOf(relation.table, key.slice(dot + 1))
             : undefined;
@@ -1033,11 +1072,22 @@ class SqlBaseCrudService {
             throw new common_1.BadRequestException(`Invalid full-text query mode: ${String(mode)} (expected 'plain' or 'websearch')`);
         }
         const parse = drizzle_orm_1.sql.raw(mode === "websearch" ? "websearch_to_tsquery" : "plainto_tsquery");
-        const vector = drizzle_orm_1.sql.join(columns.map((column) => columns.length > 1
-            ? (0, drizzle_orm_1.sql) `to_tsvector(${config}, coalesce(${column}, ''))`
-            : (0, drizzle_orm_1.sql) `to_tsvector(${config}, ${column})`), (0, drizzle_orm_1.sql) ` || `);
+        const vector = drizzle_orm_1.sql.join(columns.map((column) => {
+            if (this.isTsVector(column)) {
+                return columns.length > 1
+                    ? (0, drizzle_orm_1.sql) `coalesce(${column}, ''::tsvector)`
+                    : (0, drizzle_orm_1.sql) `${column}`;
+            }
+            return columns.length > 1
+                ? (0, drizzle_orm_1.sql) `to_tsvector(${config}, coalesce(${column}, ''))`
+                : (0, drizzle_orm_1.sql) `to_tsvector(${config}, ${column})`;
+        }), (0, drizzle_orm_1.sql) ` || `);
         return { vector, query: (0, drizzle_orm_1.sql) `${parse}(${config}, ${term})` };
     }
+    isTsVector(column) {
+        const type = typeof column?.getSQLType === "function" ? column.getSQLType() : "";
+        return String(type).trim().toLowerCase() === "tsvector";
+    }
     buildSearchCondition(search) {
         if (!search?.term || !search.columns?.length)
             return undefined;
@@ -1129,6 +1179,29 @@ class SqlBaseCrudService {
         }
         return row;
     }
+    async guardRow(id, options) {
+        const row = await this.findForGuard(id, options);
+        if (!row)
+            throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id);
+    }
+    skipsGuard(options, ...methods) {
+        if (!this.config.sql?.useReturning)
+            return false;
+        if (this.config.events && !options?.skipEvents)
+            return false;
+        const base = SqlBaseCrudService.prototype;
+        return methods.every((name) => this[name] === base[name]);
+    }
+    async guardOnError(guarded, id, options, run) {
+        try {
+            return await run();
+        }
+        catch (error) {
+            if (!guarded)
+                await this.guardRow(id, options);
+            throw error;
+        }
+    }
     assertVersion(id, actual, expected) {
         if (expected === undefined || expected === null)
             return;
@@ -1171,14 +1244,21 @@ class SqlBaseCrudService {
         };
     }
     async find(id, options) {
+        options = this.withScopeMemo(options);
         this.checkReadOptions(options);
         return this.findFirst([(0, drizzle_orm_1.eq)(this.config.table[this.config.primaryKey], id)], options);
     }
     async findOne(where, options) {
+        options = this.withScopeMemo(options);
         this.checkReadOptions(options);
         return this.findFirst(this.buildWhereConditionsFromPartial(where), options);
     }
     async findFirst(conditions, options) {
+        const first = await this.readFirst(conditions, options);
+        await first.hydrate();
+        return first.row;
+    }
+    async readFirst(conditions, options) {
         const { transaction, relations = [], select = [] } = options || {};
         const db = this.dbFor(transaction);
         const nodes = this.relationTree(relations);
@@ -1193,11 +1273,16 @@ class SqlBaseCrudService {
         query = this.applyLock(query, options);
         const result = await this.runRead(query);
         const rows = this.normalizeRelations(result, joined.map((node) => node.name));
+        return {
+            row: rows[0] || null,
+            hydrate: () => this.hydrate(db, rows, nodes, selection, options),
+        };
+    }
+    async hydrate(db, rows, nodes, selection, options) {
         await Promise.all([
             this.loadRelations(db, rows, nodes, selection, undefined, options),
             this.loadCounts(db, rows, options?.counts, options),
         ]);
-        return rows[0] || null;
     }
     planList(filters, sortBy, sortOrder, options) {
         this.checkReadOptions(options);
@@ -1234,6 +1319,9 @@ class SqlBaseCrudService {
         built.conditions.push(...this.rowScope(options));
         return built;
     }
+    parseCount(result) {
+        return parseInt(result?.[0]?.count?.toString() || "0", 10);
+    }
     buildCountQuery(db, conditions, filterRelations, options) {
         let query = db
             .select({ count: (0, drizzle_orm_1.sql) `count(*)` })
@@ -1244,6 +1332,7 @@ class SqlBaseCrudService {
         return query;
     }
     async findAll(filters, pagination, options) {
+        options = this.withScopeMemo(options);
         const { sortBy, sortOrder = "asc" } = pagination || {};
         const withCount = pagination?.withCount !== false;
         const { page, limit: safeLimit, offset, } = this.resolvePagination(pagination?.page, pagination?.limit);
@@ -1266,10 +1355,7 @@ class SqlBaseCrudService {
         const [fetched, totalResult] = await this.runRead(Promise.all([dataQuery, countQuery]));
         const data = fetched.slice(0, safeLimit);
         const rows = this.normalizeRelations(data, plan.joined.map((node) => node.name));
-        await Promise.all([
-            this.loadRelations(plan.db, rows, plan.nodes, plan.selection, undefined, options),
-            this.loadCounts(plan.db, rows, options?.counts, options),
-        ]);
+        await this.hydrate(plan.db, rows, plan.nodes, plan.selection, options);
         if (!withCount) {
             return {
                 data: rows,
@@ -1281,12 +1367,13 @@ class SqlBaseCrudService {
         }
         return {
             data: rows,
-            total: parseInt(totalResult[0]?.count?.toString() || "0", 10),
+            total: this.parseCount(totalResult),
             page,
             limit: safeLimit,
         };
     }
     async findByCursor(filters, pagination, options) {
+        options = this.withScopeMemo(options);
         const { sortBy, sortOrder = "asc", count = false } = pagination || {};
         const { limit } = this.resolvePagination(1, pagination?.limit);
         const plan = this.planList(filters, sortBy, sortOrder, options);
@@ -1303,9 +1390,17 @@ class SqlBaseCrudService {
             conditions.push(this.keysetCondition(plan.sort, values));
         }
         const fields = this.buildSelection(plan.baseSelect, plan.joined, plan.selection);
-        plan.sort.forEach((spec, i) => {
-            fields[`${CURSOR_KEY}${i}`] = this.cursorField(spec.column);
+        const cursorKeys = plan.sort.map((spec, i) => {
+            const field = this.cursorField(spec.column);
+            const projected = field === spec.column && !spec.relation
+                ? Object.keys(fields).find((key) => fields[key] === spec.column)
+                : undefined;
+            if (projected)
+                return projected;
+            fields[`${CURSOR_KEY}${i}`] = field;
+            return `${CURSOR_KEY}${i}`;
         });
+        const hidden = cursorKeys.filter((key) => key.startsWith(CURSOR_KEY));
         let dataQuery = plan.db.select(fields).from(this.config.table);
         dataQuery = this.applyJoins(dataQuery, plan.joinRelations, options);
         if (conditions.length > 0)
@@ -1323,21 +1418,17 @@ class SqlBaseCrudService {
         const page = data.slice(0, limit);
         const last = page[page.length - 1];
         const nextCursor = data.length > limit && last
-            ? (0, cursor_1.encodeCursor)(plan.sort.map((_, i) => last[`${CURSOR_KEY}${i}`]), signature)
+            ? (0, cursor_1.encodeCursor)(cursorKeys.map((key) => last[key]), signature)
             : null;
         for (const row of page) {
-            plan.sort.forEach((_, i) => {
-                delete row[`${CURSOR_KEY}${i}`];
-            });
+            for (const key of hidden)
+                delete row[key];
         }
         const rows = this.normalizeRelations(page, plan.joined.map((node) => node.name));
-        await Promise.all([
-            this.loadRelations(plan.db, rows, plan.nodes, plan.selection, undefined, options),
-            this.loadCounts(plan.db, rows, options?.counts, options),
-        ]);
+        await this.hydrate(plan.db, rows, plan.nodes, plan.selection, options);
         const out = { data: rows, limit, nextCursor };
         if (count) {
-            out.total = parseInt(totalResult?.[0]?.count?.toString() || "0", 10);
+            out.total = this.parseCount(totalResult);
         }
         return out;
     }
@@ -1356,9 +1447,16 @@ class SqlBaseCrudService {
             return (0, drizzle_orm_1.gt)(column, value);
         if (op === "<")
             return (0, drizzle_orm_1.lt)(column, value);
+        if (op === ">=")
+            return (0, drizzle_orm_1.gte)(column, value);
+        if (op === "<=")
+            return (0, drizzle_orm_1.lte)(column, value);
         return (0, drizzle_orm_1.eq)(column, value);
     }
     keysetCondition(specs, values) {
+        const row = this.keysetRowComparison(specs, values);
+        if (row)
+            return row;
         const branches = [];
         specs.forEach((spec, i) => {
             const after = this.afterCursor(spec, values[i]);
@@ -1371,21 +1469,64 @@ class SqlBaseCrudService {
                 : this.compareCursor(previous.column, "=", values[j]));
             branches.push(ties.length > 0 ? (0, drizzle_orm_1.and)(...ties, after) : after);
         });
-        return branches.length > 0 ? (0, drizzle_orm_1.or)(...branches) : (0, drizzle_orm_1.sql) `false`;
+        if (branches.length === 0)
+            return (0, drizzle_orm_1.sql) `false`;
+        const after = (0, drizzle_orm_1.or)(...branches);
+        const bound = this.keysetBound(specs, values);
+        return bound ? (0, drizzle_orm_1.and)(bound, after) : after;
+    }
+    keysetBound(specs, values) {
+        const [first] = specs;
+        if (!first || specs.length < 2 || values[0] === null)
+            return undefined;
+        if (this.keysetNullable(first) && !this.nullsFirst(first)) {
+            return undefined;
+        }
+        return this.compareCursor(first.column, first.order === "asc" ? ">=" : "<=", values[0]);
+    }
+    keysetRowComparison(specs, values) {
+        if (this.config.dialect !== "postgresql" || specs.length < 2) {
+            return undefined;
+        }
+        const order = specs[0].order;
+        const fits = specs.every((spec, i) => spec.order === order &&
+            values[i] !== null &&
+            !this.keysetNullable(spec));
+        if (!fits)
+            return undefined;
+        const columns = drizzle_orm_1.sql.join(specs.map((spec) => spec.column), (0, drizzle_orm_1.sql) `, `);
+        const params = drizzle_orm_1.sql.join(specs.map((spec, i) => spec.column?.dataType === "date"
+            ? (0, drizzle_orm_1.sql) `${values[i]}`
+            : drizzle_orm_1.sql.param(values[i], spec.column)), (0, drizzle_orm_1.sql) `, `);
+        return (0, drizzle_orm_1.sql) `(${columns}) ${drizzle_orm_1.sql.raw(order === "asc" ? ">" : "<")} (${params})`;
+    }
+    keysetNullable(spec) {
+        if (spec.relation)
+            return true;
+        return !(spec.column?.notNull || spec.column?.primary);
+    }
+    nullsFirst(spec) {
+        return this.config.dialect === "postgresql"
+            ? spec.order === "desc"
+            : spec.order === "asc";
     }
     afterCursor(spec, value) {
-        const postgres = this.config.dialect === "postgresql";
-        const nullsFirst = postgres ? spec.order === "desc" : spec.order === "asc";
+        const nullsFirst = this.nullsFirst(spec);
         if (value === null) {
             return nullsFirst ? (0, drizzle_orm_1.isNotNull)(spec.column) : undefined;
         }
         const past = this.compareCursor(spec.column, spec.order === "asc" ? ">" : "<", value);
-        return nullsFirst ? past : (0, drizzle_orm_1.or)(past, (0, drizzle_orm_1.isNull)(spec.column));
+        return nullsFirst || !this.keysetNullable(spec)
+            ? past
+            : (0, drizzle_orm_1.or)(past, (0, drizzle_orm_1.isNull)(spec.column));
     }
     async emitEvent(phase, operation, bulk, payload, options) {
         const bus = this.config.events;
         if (!bus || options?.skipEvents)
             return;
+        if (payload.transaction && typeof payload.transaction === "object") {
+            this.ownedTransactions.delete(payload.transaction);
+        }
         await bus.emit({
             entity: this.getEntityName(),
             operation,
@@ -1407,10 +1548,26 @@ class SqlBaseCrudService {
             return;
         }
         const hosts = rows.filter(Boolean);
-        await Promise.all([
-            this.loadRelations(db, hosts, nodes, undefined, undefined, options),
-            this.loadCounts(db, hosts, options?.counts, options),
-        ]);
+        await this.hydrate(db, hosts, nodes, undefined, options);
+    }
+    loadsAfterCommit(options) {
+        if (options?.transaction)
+            return false;
+        try {
+            return this.countPlan(options?.counts).every((count) => !count.filter);
+        }
+        catch {
+            return false;
+        }
+    }
+    async writeThenLoad(options, write) {
+        const late = this.loadsAfterCommit(options);
+        const rows = await this.executeSqlTransaction((tx) => write(tx, (inTx, written) => late
+            ? Promise.resolve()
+            : this.loadWriteRelations(inTx, written, options)), options?.transaction);
+        if (late)
+            await this.loadWriteRelations(this.dbFor(), rows, options);
+        return rows;
     }
     expectedVersionOf(data, options) {
         const column = this.config.versionColumn;
@@ -1466,6 +1623,7 @@ class SqlBaseCrudService {
         return createdEntity;
     }
     async create(data, options) {
+        options = this.withScopeMemo(options);
         const { transaction, hooks = {} } = options || {};
         this.checkReadOptions(options);
         const entityData = await this.prepareCreate(data, options);
@@ -1564,7 +1722,7 @@ class SqlBaseCrudService {
                     .returning();
                 ids.push(...inserted.map((r) => r[relation.references ?? "id"]));
             }
-            await this.linkTargets(tx, relation, parentValue, ids, options);
+            await this.linkTargets(tx, relation, parentValue, ids, options, true);
         }
         return created;
     }
@@ -1645,7 +1803,7 @@ class SqlBaseCrudService {
             : "reference";
         return new crud_exceptions_1.ForeignKeyViolationException(this.getEntityName(), field);
     }
-    async linkTargets(tx, relation, parentValue, ids, options) {
+    async linkTargets(tx, relation, parentValue, ids, options, fresh = false) {
         const wanted = this.uniqueValues(ids);
         if (wanted.length === 0)
             return;
@@ -1669,10 +1827,12 @@ class SqlBaseCrudService {
                 error: new crud_exceptions_1.EntityNotFoundException(name, id),
             })));
         }
-        const linked = await tx
-            .select({ id: foreign })
-            .from(through)
-            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(local, parentValue), (0, drizzle_orm_1.inArray)(foreign, wanted)));
+        const linked = fresh
+            ? []
+            : await tx
+                .select({ id: foreign })
+                .from(through)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(local, parentValue), (0, drizzle_orm_1.inArray)(foreign, wanted)));
         const already = new Set(linked.map((row) => this.valueKey(row.id)));
         const add = wanted.filter((id) => !already.has(this.valueKey(id)));
         if (add.length > 0) {
@@ -1683,19 +1843,19 @@ class SqlBaseCrudService {
         }
     }
     async attach(id, relation, relatedIds, options) {
+        options = this.withScopeMemo(options);
         return this.changeLinks("attach", id, relation, relatedIds, options);
     }
     async detach(id, relation, relatedIds, options) {
+        options = this.withScopeMemo(options);
         return this.changeLinks("detach", id, relation, relatedIds, options);
     }
     async sync(id, relation, relatedIds, options) {
+        options = this.withScopeMemo(options);
         return this.changeLinks("sync", id, relation, relatedIds, options);
     }
     async changeLinks(operation, id, name, relatedIds, options) {
-        const relations = this.config.relations || {};
-        const relation = Object.hasOwn(relations, name)
-            ? relations[name]
-            : undefined;
+        const relation = this.relationNamed(name);
         if (!relation || this.relationType(relation) !== "manyToMany") {
             throw new common_1.BadRequestException(`"${name}" is not a many-to-many relation of ${this.getEntityName()}`);
         }
@@ -1716,13 +1876,13 @@ class SqlBaseCrudService {
         const parentKey = this.parentKeyOf(relation);
         return this.executeSqlTransaction(async (tx) => {
             const opts = { ...options, transaction: tx };
-            const parent = await this.find(id, {
+            const read = {
                 ...opts,
-                relations: [],
-                counts: undefined,
-                select: [this.config.primaryKey, parentKey],
+                relations: Array.from(new Set([name, ...(options?.relations ?? [])])),
                 skipAllowlists: true,
-            });
+            };
+            this.checkReadOptions(read);
+            const { row: parent, hydrate } = await this.readFirst([(0, drizzle_orm_1.eq)(this.config.table[this.config.primaryKey], id)], read);
             if (!parent)
                 throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id);
             await this.emitEvent("before", operation, false, { ids: [id], input: relatedIds, transaction: tx }, options);
@@ -1750,11 +1910,8 @@ class SqlBaseCrudService {
                         : (0, drizzle_orm_1.eq)(local, parentValue));
                 }
             }
-            const row = (await this.find(id, {
-                ...opts,
-                relations: Array.from(new Set([name, ...(options?.relations ?? [])])),
-                skipAllowlists: true,
-            }));
+            await hydrate();
+            const row = parent;
             await this.emitEvent("after", operation, false, { ids: [id], input: relatedIds, rows: [row], transaction: tx }, options);
             return row;
         }, options?.transaction);
@@ -1796,27 +1953,31 @@ class SqlBaseCrudService {
         return entityData;
     }
     async update(id, data, options) {
+        options = this.withScopeMemo(options);
         const { transaction, hooks = {} } = options || {};
         this.checkReadOptions(options);
         const expected = this.expectedVersionOf(data, options);
         const opts = { ...options, expectedVersion: expected };
-        const existing = await this.findForGuard(id, opts);
-        if (!existing)
-            throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id);
-        await this.validateUpdate(id, data);
-        const processedData = hooks.skipBefore
-            ? data
-            : await this.beforeUpdate(id, data);
-        const entityData = this.prepareUpdate(processedData, opts);
+        const guarded = !this.skipsGuard(options, "validateUpdate", "mapUpdateDtoToEntity", ...(hooks.skipBefore ? [] : ["beforeUpdate"]));
+        if (guarded)
+            await this.guardRow(id, opts);
+        const entityData = await this.guardOnError(guarded, id, opts, async () => {
+            await this.validateUpdate(id, data);
+            const processedData = hooks.skipBefore
+                ? data
+                : await this.beforeUpdate(id, data);
+            return this.prepareUpdate(processedData, opts);
+        });
         if (this.config.timestamps?.updatedAt) {
             entityData[this.config.timestamps.updatedAt] = new Date();
         }
         const db = this.dbFor(transaction);
         await this.emitEvent("before", "update", false, { ids: [id], input: data, transaction }, options);
         try {
-            await this.assertKeysInScope(db, entityData, opts);
-            const [updatedEntity] = await this.updateWhereIn(db, this.withVersionBump(entityData), [id], opts);
+            await this.guardOnError(guarded, id, opts, () => this.assertKeysInScope(db, entityData, opts));
+            const [updatedEntity] = await this.updateWhereIn(db, this.withVersionBump(entityData), [id], opts, this.softDeleteScope(opts));
             if (!updatedEntity) {
+                await this.guardRow(id, opts);
                 if (expected !== undefined) {
                     throw new crud_exceptions_1.StaleVersionException(this.getEntityName(), id);
                 }
@@ -1832,11 +1993,12 @@ class SqlBaseCrudService {
             throw this.toClientError(error, "write");
         }
     }
-    async updateWhereIn(db, set, ids, options) {
+    async updateWhereIn(db, set, ids, options, extra) {
+        const where = this.writeWhere(ids, options);
         const query = db
             .update(this.config.table)
             .set(set)
-            .where(this.writeWhere(ids, options));
+            .where(extra ? (0, drizzle_orm_1.and)(where, extra) : where);
         if (this.config.sql?.useReturning) {
             return this.inIdOrder(await query.returning(), ids);
         }
@@ -1862,39 +2024,65 @@ class SqlBaseCrudService {
             .map((id) => byKey.get(this.keyOf(id)))
             .filter((row) => !!row);
     }
-    async softDelete(id, options) {
-        if (!this.config.softDelete?.enabled) {
-            throw new common_1.BadRequestException("Soft delete is not enabled for this entity");
-        }
+    async guardedWrite(id, options, step) {
         const { transaction, hooks = {} } = options || {};
-        const existing = await this.findForGuard(id, {
-            ...options,
-            withDeleted: false,
-            onlyDeleted: false,
-        });
-        if (!existing)
-            throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id);
+        if (!this.skipsGuard(options, ...(hooks.skipBefore ? [] : [step.hook]))) {
+            await this.guardRow(id, step.state);
+        }
         if (!hooks.skipBefore)
-            await this.beforeSoftDelete(id);
-        await this.emitEvent("before", "softDelete", false, { ids: [id], transaction }, options);
-        const db = this.dbFor(transaction);
-        let updateQuery = db
-            .update(this.config.table)
-            .set(this.softDeleteSet(new Date()))
-            .where(this.writeWhere([id], options));
-        if (this.config.sql?.useReturning)
-            updateQuery = updateQuery.returning();
-        const result = await this.runRead(updateQuery);
-        const success = this.wasAffected(result);
-        if (!success && options?.expectedVersion != null) {
+            await step.before();
+        const event = { ids: [id], transaction };
+        await this.emitEvent("before", step.operation, false, event, options);
+        const finish = async () => {
+            const result = await step.write(this.dbFor(transaction));
+            if (result === undefined) {
+                await this.guardRow(id, step.state);
+                return step.miss();
+            }
+            if (!hooks.skipAfter)
+                await step.after(result);
+            const rows = step.rows?.(result);
+            await this.emitEvent("after", step.operation, false, { ...event, rows }, options);
+            return result;
+        };
+        if (!step.errors)
+            return finish();
+        try {
+            return await finish();
+        }
+        catch (error) {
+            throw this.toClientError(error, step.errors);
+        }
+    }
+    staleOrFalse(id, options) {
+        if (options?.expectedVersion != null) {
             throw new crud_exceptions_1.StaleVersionException(this.getEntityName(), id);
         }
-        if (success && !hooks.skipAfter)
-            await this.afterSoftDelete(id);
-        if (success) {
-            await this.emitEvent("after", "softDelete", false, { ids: [id], transaction }, options);
+        return false;
+    }
+    async softDelete(id, options) {
+        options = this.withScopeMemo(options);
+        if (!this.config.softDelete?.enabled) {
+            throw new common_1.BadRequestException("Soft delete is not enabled for this entity");
         }
-        return success;
+        const live = { ...options, withDeleted: false, onlyDeleted: false };
+        return this.guardedWrite(id, options, {
+            operation: "softDelete",
+            state: live,
+            hook: "beforeSoftDelete",
+            before: () => this.beforeSoftDelete(id),
+            write: async (db) => {
+                let query = db
+                    .update(this.config.table)
+                    .set(this.softDeleteSet(new Date()))
+                    .where((0, drizzle_orm_1.and)(this.writeWhere([id], options), this.softDeleteScope(live)));
+                if (this.config.sql?.useReturning)
+                    query = query.returning();
+                return this.wasAffected(await this.runRead(query)) || undefined;
+            },
+            miss: () => this.staleOrFalse(id, options),
+            after: () => this.afterSoftDelete(id),
+        });
     }
     softDeleteSet(deletedAt) {
         return this.withVersionBump({
@@ -1905,62 +2093,43 @@ class SqlBaseCrudService {
         });
     }
     async restore(id, options) {
+        options = this.withScopeMemo(options);
         if (!this.config.softDelete?.enabled) {
             throw new common_1.BadRequestException("Soft delete is not enabled for this entity");
         }
-        const { transaction, hooks = {} } = options || {};
-        const existing = await this.findForGuard(id, {
-            ...options,
-            withDeleted: false,
-            onlyDeleted: true,
+        const trashed = { ...options, withDeleted: false, onlyDeleted: true };
+        const restored = await this.guardedWrite(id, options, {
+            operation: "restore",
+            state: trashed,
+            hook: "beforeRestore",
+            before: () => this.beforeRestore(id),
+            write: async (db) => (await this.runRead(this.updateWhereIn(db, this.softDeleteSet(null), [id], options, this.softDeleteScope(trashed))))[0],
+            miss: () => {
+                if (options?.expectedVersion != null && this.config.versionColumn) {
+                    throw new crud_exceptions_1.StaleVersionException(this.getEntityName(), id);
+                }
+                throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id);
+            },
+            after: (entity) => this.afterRestore(entity),
+            rows: (entity) => [entity],
         });
-        if (!existing)
-            throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id);
-        if (!hooks.skipBefore)
-            await this.beforeRestore(id);
-        await this.emitEvent("before", "restore", false, { ids: [id], transaction }, options);
-        const db = this.dbFor(transaction);
-        const [restoredEntity] = await this.runRead(this.updateWhereIn(db, this.softDeleteSet(null), [id], options));
-        if (!restoredEntity) {
-            if (options?.expectedVersion != null && this.config.versionColumn) {
-                throw new crud_exceptions_1.StaleVersionException(this.getEntityName(), id);
-            }
-            throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id);
-        }
-        if (!hooks.skipAfter)
-            await this.afterRestore(restoredEntity);
-        await this.emitEvent("after", "restore", false, { ids: [id], rows: [restoredEntity], transaction }, options);
-        await this.loadWriteRelations(db, [restoredEntity], options);
-        return restoredEntity;
+        await this.loadWriteRelations(this.dbFor(options?.transaction), [restored], options);
+        return restored;
     }
     async delete(id, options) {
-        const { transaction, hooks = {} } = options || {};
-        const existing = await this.findForGuard(id, options);
-        if (!existing)
-            throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id);
-        if (!hooks.skipBefore)
-            await this.beforeDelete(id);
-        await this.emitEvent("before", "delete", false, { ids: [id], transaction }, options);
-        const db = this.dbFor(transaction);
-        const deleteQuery = db
-            .delete(this.config.table)
-            .where(this.writeWhere([id], options));
-        try {
-            const result = await deleteQuery;
-            const success = this.wasAffected(result);
-            if (!success && options?.expectedVersion != null) {
-                throw new crud_exceptions_1.StaleVersionException(this.getEntityName(), id);
-            }
-            if (success && !hooks.skipAfter)
-                await this.afterDelete(id);
-            if (success) {
-                await this.emitEvent("after", "delete", false, { ids: [id], transaction }, options);
-            }
-            return success;
-        }
-        catch (error) {
-            throw this.toClientError(error, "delete");
-        }
+        options = this.withScopeMemo(options);
+        return this.guardedWrite(id, options, {
+            operation: "delete",
+            state: options,
+            hook: "beforeDelete",
+            before: () => this.beforeDelete(id),
+            write: async (db) => this.wasAffected(await db
+                .delete(this.config.table)
+                .where((0, drizzle_orm_1.and)(this.writeWhere([id], options), this.softDeleteScope(options)))) || undefined,
+            miss: () => this.staleOrFalse(id, options),
+            after: () => this.afterDelete(id),
+            errors: "delete",
+        });
     }
     async forceDelete(id, options) {
         return this.delete(id, {
@@ -1970,6 +2139,7 @@ class SqlBaseCrudService {
         });
     }
     async upsert(data, upsert = {}, options) {
+        options = this.withScopeMemo(options);
         this.checkReadOptions(options);
         const entityData = await this.prepareCreate(data, options);
         const db = this.dbFor(options?.transaction);
@@ -1995,43 +2165,40 @@ class SqlBaseCrudService {
         return row;
     }
     async massUpsert(data, upsert = {}, options) {
-        this.checkReadOptions(options);
+        options = this.withScopeMemo(options);
         const message = "Mass upsert errors";
-        return this.executeSqlTransaction(async (tx) => {
-            const opts = { ...options, transaction: tx };
-            const rows = await this.eachItem(data.map((item, index) => ({
+        return this.massWrite({
+            operation: "upsert",
+            message,
+            options,
+            input: data,
+            returnsRows: true,
+            prepare: (opts) => data.map((item, index) => ({
                 index,
                 run: () => this.prepareCreate(item, opts),
-            })), message);
-            if (rows.length === 0)
-                return [];
-            await this.emitEvent("before", "upsert", true, { input: data, transaction: tx }, options);
-            await this.assertBatchKeysInScope(tx, rows, rows.map((_, index) => ({ index })), message, opts);
-            const written = await this.runSet(tx, message, (sp) => this.upsertRows(sp, rows, upsert, opts), rows.map((row, index) => ({
-                index,
-                run: (sp) => this.upsertRows(sp, [row], upsert, opts),
-            })), "write");
-            if (written.length < rows.length) {
-                const keys = this.conflictKeys(upsert);
-                const seen = new Set(written.map((row) => keys.map((k) => this.valueKey(row[k])).join("|")));
-                throw new crud_exceptions_1.BulkOperationException(message, rows.flatMap((row, index) => seen.has(keys.map((k) => this.valueKey(row[k])).join("|"))
-                    ? []
-                    : [
-                        {
-                            index,
-                            error: new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), this.conflictValue(row, upsert)),
-                        },
-                    ]));
-            }
-            await this.emitEvent("after", "upsert", true, {
-                ids: this.idsOf(written),
-                input: data,
-                rows: written,
-                transaction: tx,
-            }, options);
-            await this.loadWriteRelations(tx, written, options);
+            })),
+            keys: true,
+            write: (tx, rows, opts) => this.upsertSet(tx, rows, upsert, opts, message),
+        });
+    }
+    async upsertSet(tx, rows, upsert, opts, message) {
+        const written = await this.runSet(tx, message, (sp) => this.upsertRows(sp, rows, upsert, opts), rows.map((row, index) => ({
+            index,
+            run: (sp) => this.upsertRows(sp, [row], upsert, opts),
+        })), "write");
+        if (written.length >= rows.length)
             return written;
-        }, options?.transaction);
+        const keys = this.conflictKeys(upsert);
+        const keyOf = (row) => keys.map((k) => this.valueKey(row[k])).join("|");
+        const seen = new Set(written.map(keyOf));
+        throw new crud_exceptions_1.BulkOperationException(message, rows.flatMap((row, index) => seen.has(keyOf(row))
+            ? []
+            : [
+                {
+                    index,
+                    error: new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), this.conflictValue(row, upsert)),
+                },
+            ]));
     }
     conflictKeys(upsert) {
         return upsert.conflictTarget === undefined
@@ -2126,38 +2293,78 @@ class SqlBaseCrudService {
             ? (0, drizzle_orm_1.sql) `values(${drizzle_orm_1.sql.identifier(column.name)})`
             : (0, drizzle_orm_1.sql) `excluded.${drizzle_orm_1.sql.identifier(column.name)}`;
     }
+    async massWrite(spec) {
+        const { options, message, ids } = spec;
+        if (spec.returnsRows)
+            this.checkReadOptions(options);
+        const body = async (tx, load) => {
+            const opts = { ...options, transaction: tx, ...spec.state };
+            const unique = ids ? this.uniqueIds(ids) : [];
+            if (ids) {
+                if (unique.length === 0)
+                    return [];
+                await this.assertAllExist(tx, unique, opts, message);
+            }
+            const items = spec.prepare?.(opts, unique);
+            const prepared = items ? await this.eachItem(items, message) : [];
+            if (!ids && prepared.length === 0)
+                return [];
+            const event = {
+                ids: ids ? unique : undefined,
+                input: spec.input,
+                transaction: tx,
+            };
+            await this.emitEvent("before", spec.operation, true, event, options);
+            if (spec.keys) {
+                await this.assertBatchKeysInScope(tx, prepared, ids
+                    ? unique.map((id) => ({ id }))
+                    : prepared.map((_, index) => ({ index })), message, opts);
+            }
+            const written = await spec.write(tx, prepared, opts, unique);
+            if (ids)
+                this.assertAllWritten(unique, written, message, options);
+            if (spec.after && !options?.hooks?.skipAfter) {
+                await spec.after(written, unique);
+            }
+            await this.emitEvent("after", spec.operation, true, {
+                ...event,
+                ids: ids ? unique : this.idsOf(written),
+                rows: spec.returnsRows ? written : undefined,
+            }, options);
+            if (spec.returnsRows)
+                await load(tx, written);
+            return ids ? this.inIdOrder(written, ids) : written;
+        };
+        return spec.returnsRows
+            ? this.writeThenLoad(options, body)
+            : this.executeSqlTransaction((tx) => body(tx, async () => { }), options?.transaction);
+    }
     async massCreate(data, options) {
+        options = this.withScopeMemo(options);
         if (options?.bulkMode === "perItem") {
-            return this.massCreatePerItem(data, options);
+            return this.eachInSavepoint(data.map((item, index) => ({ index, item })), "Mass create errors", options, ({ item }, opts) => this.create(item, opts));
         }
-        this.checkReadOptions(options);
-        return this.executeSqlTransaction(async (tx) => {
-            const opts = { ...options, transaction: tx };
-            const rows = await this.eachItem(data.map((item, index) => ({
+        const message = "Mass create errors";
+        return this.massWrite({
+            operation: "create",
+            message,
+            options,
+            input: data,
+            returnsRows: true,
+            prepare: (opts) => data.map((item, index) => ({
                 index,
                 run: () => this.prepareCreate(item, opts),
-            })), "Mass create errors");
-            if (rows.length === 0)
-                return [];
-            await this.emitEvent("before", "create", true, { input: data, transaction: tx }, options);
-            await this.assertBatchKeysInScope(tx, rows, rows.map((_, index) => ({ index })), "Mass create errors", opts);
-            const created = await this.runSet(tx, "Mass create errors", (sp) => this.insertMany(sp, rows, opts), rows.map((row, index) => ({
+            })),
+            keys: true,
+            write: (tx, rows, opts) => this.runSet(tx, message, (sp) => this.insertMany(sp, rows, opts), rows.map((row, index) => ({
                 index,
                 run: (sp) => this.insertOne(sp, row, opts),
-            })), "write");
-            if (!options?.hooks?.skipAfter) {
+            })), "write"),
+            after: async (created) => {
                 for (const entity of created)
                     await this.afterCreate(entity);
-            }
-            await this.emitEvent("after", "create", true, {
-                ids: this.idsOf(created),
-                input: data,
-                rows: created,
-                transaction: tx,
-            }, options);
-            await this.loadWriteRelations(tx, created, options);
-            return created;
-        }, options?.transaction);
+            },
+        });
     }
     async insertMany(db, rows, options) {
         if (this.config.sql?.useReturning) {
@@ -2168,9 +2375,28 @@ class SqlBaseCrudService {
             await db.insert(this.config.table).values(rows);
             return this.fetchByIds(db, rows.map((row) => row[pk]), options);
         }
-        const created = [];
-        for (const row of rows)
-            created.push(await this.insertOne(db, row, options));
+        const ids = [];
+        for (const row of rows) {
+            const result = await db.insert(this.config.table).values(row);
+            ids.push(row[pk] ?? result?.[0]?.insertId);
+        }
+        return this.readBackCreated(db, ids, options);
+    }
+    async readBackCreated(db, ids, options) {
+        const pk = this.config.primaryKey;
+        const base = this.parseSelect(options?.select).base;
+        const fields = this.buildSelectFields(base.length > 0 ? Array.from(new Set([...base, pk])) : base);
+        const column = this.config.table[pk];
+        const rows = await (fields ? db.select(fields) : db.select())
+            .from(this.config.table)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.inArray)(column, ids), ...this.rowScope(options)));
+        const created = this.inIdOrder(rows, ids);
+        if (created.length < ids.length)
+            throw new Error("Failed to create entity");
+        if (fields && !base.includes(pk)) {
+            for (const row of created)
+                delete row[pk];
+        }
         return created;
     }
     assertAllWritten(ids, written, message, options) {
@@ -2187,59 +2413,62 @@ class SqlBaseCrudService {
         })));
     }
     async massUpdate(ids, data, options) {
+        options = this.withScopeMemo(options);
         if (options?.bulkMode === "perItem") {
-            return this.massUpdatePerItem(ids, data, options);
+            return this.eachInSavepoint(ids.map((id) => ({ id })), "Mass update errors", options, ({ id }, opts) => this.update(id, data, opts));
         }
-        this.checkReadOptions(options);
         const message = "Mass update errors";
-        return this.executeSqlTransaction(async (tx) => {
-            const opts = { ...options, transaction: tx };
-            const hooks = options?.hooks ?? {};
-            const unique = this.uniqueIds(ids);
-            if (unique.length === 0)
-                return [];
-            await this.assertAllExist(tx, unique, opts, message);
-            const sets = await this.eachItem(unique.map((id) => ({
+        const skipBefore = options?.hooks?.skipBefore;
+        return this.massWrite({
+            operation: "update",
+            message,
+            options,
+            ids,
+            input: data,
+            returnsRows: true,
+            prepare: (opts, unique) => unique.map((id) => ({
                 id,
                 run: async () => {
                     await this.validateUpdate(id, data);
-                    const processed = hooks.skipBefore
+                    const processed = skipBefore
                         ? data
                         : await this.beforeUpdate(id, data);
                     return this.prepareUpdate(processed, opts);
                 },
-            })), message);
-            await this.emitEvent("before", "update", true, { ids: unique, input: data, transaction: tx }, options);
-            await this.assertBatchKeysInScope(tx, sets, unique.map((id) => ({ id })), message, opts);
-            const now = new Date();
-            const stamp = (set) => this.withVersionBump(this.config.timestamps?.updatedAt
-                ? { ...set, [this.config.timestamps.updatedAt]: now }
-                : set);
-            let updated;
-            const first = this.fingerprint(sets[0]);
-            if (sets.every((set) => this.fingerprint(set) === first)) {
-                const set = stamp(sets[0]);
-                updated = await this.runSet(tx, message, (sp) => this.updateWhereIn(sp, set, unique, opts), unique.map((id) => ({
-                    id,
-                    run: (sp) => this.updateWhereIn(sp, set, [id], opts),
-                })), "write");
-            }
-            else {
-                const rows = await this.eachItem(unique.map((id, i) => ({
-                    id,
-                    run: () => this.savepoint(tx, (sp) => this.updateWhereIn(sp, stamp(sets[i]), [id], opts)),
-                })), message, "write");
-                updated = rows.flat();
-            }
-            this.assertAllWritten(unique, updated, message, options);
-            if (!hooks.skipAfter) {
+            })),
+            keys: true,
+            write: (tx, sets, opts, unique) => this.updateSets(tx, sets, unique, opts, message),
+            after: async (updated) => {
                 for (const entity of updated)
                     await this.afterUpdate(entity);
+            },
+        });
+    }
+    async updateSets(tx, sets, unique, opts, message) {
+        const now = new Date();
+        const stamp = (set) => this.withVersionBump(this.config.timestamps?.updatedAt
+            ? { ...set, [this.config.timestamps.updatedAt]: now }
+            : set);
+        const groups = new Map();
+        unique.forEach((id, i) => {
+            const key = this.fingerprint(sets[i]);
+            const group = groups.get(key);
+            if (group)
+                group.ids.push(id);
+            else
+                groups.set(key, { set: stamp(sets[i]), ids: [id] });
+        });
+        const written = await this.runSet(tx, message, async (sp) => {
+            const rows = [];
+            for (const group of groups.values()) {
+                rows.push(...(await this.updateWhereIn(sp, group.set, group.ids, opts)));
             }
-            await this.emitEvent("after", "update", true, { ids: unique, input: data, rows: updated, transaction: tx }, options);
-            await this.loadWriteRelations(tx, updated, options);
-            return this.inIdOrder(updated, ids);
-        }, options?.transaction);
+            return rows;
+        }, unique.map((id, i) => ({
+            id,
+            run: (sp) => this.updateWhereIn(sp, stamp(sets[i]), [id], opts),
+        })), "write");
+        return groups.size > 1 ? this.inIdOrder(written, unique) : written;
     }
     async runKeyed(statement, ids) {
         if (this.config.sql?.useReturning) {
@@ -2253,115 +2482,96 @@ class SqlBaseCrudService {
             : [];
     }
     async massSoftDelete(ids, options) {
+        options = this.withScopeMemo(options);
         if (!this.config.softDelete?.enabled)
             throw new common_1.BadRequestException("Soft delete not enabled");
         if (options?.bulkMode === "perItem") {
-            return this.massSoftDeletePerItem(ids, options);
+            await this.eachInSavepoint(ids.map((id) => ({ id })), "Mass soft delete errors", options, ({ id }, opts) => this.softDelete(id, opts));
+            return true;
         }
         const message = "Mass soft delete errors";
-        return this.executeSqlTransaction(async (tx) => {
-            const opts = {
-                ...options,
-                transaction: tx,
-                withDeleted: false,
-                onlyDeleted: false,
-            };
-            const hooks = options?.hooks ?? {};
-            const unique = this.uniqueIds(ids);
-            if (unique.length === 0)
-                return true;
-            await this.assertAllExist(tx, unique, opts, message);
-            if (!hooks.skipBefore) {
-                await this.eachItem(unique.map((id) => ({ id, run: () => this.beforeSoftDelete(id) })), message);
-            }
-            await this.emitEvent("before", "softDelete", true, { ids: unique, transaction: tx }, options);
-            const set = this.softDeleteSet(new Date());
-            const written = await this.runSet(tx, message, (sp) => this.runKeyed(sp
-                .update(this.config.table)
-                .set(set)
-                .where(this.writeWhere(unique, opts)), unique), unique.map((id) => ({
-                id,
-                run: (sp) => sp
+        await this.massWrite({
+            operation: "softDelete",
+            message,
+            options,
+            ids,
+            state: { withDeleted: false, onlyDeleted: false },
+            returnsRows: false,
+            prepare: (_opts, unique) => options?.hooks?.skipBefore
+                ? undefined
+                : unique.map((id) => ({ id, run: () => this.beforeSoftDelete(id) })),
+            write: (tx, _prepared, opts, unique) => {
+                const set = this.softDeleteSet(new Date());
+                const update = (db, keys) => db
                     .update(this.config.table)
                     .set(set)
-                    .where(this.writeWhere([id], opts)),
-            })), "write");
-            this.assertAllWritten(unique, written, message, options);
-            if (!hooks.skipAfter) {
+                    .where(this.writeWhere(keys, opts));
+                return this.runSet(tx, message, (sp) => this.runKeyed(update(sp, unique), unique), unique.map((id) => ({ id, run: (sp) => update(sp, [id]) })), "write");
+            },
+            after: async (_written, unique) => {
                 for (const id of unique)
                     await this.afterSoftDelete(id);
-            }
-            await this.emitEvent("after", "softDelete", true, { ids: unique, transaction: tx }, options);
-            return true;
-        }, options?.transaction);
+            },
+        });
+        return true;
     }
     async massRestore(ids, options) {
+        options = this.withScopeMemo(options);
         if (!this.config.softDelete?.enabled)
             throw new common_1.BadRequestException("Soft delete not enabled");
         if (options?.bulkMode === "perItem") {
-            return this.massRestorePerItem(ids, options);
+            return this.eachInSavepoint(ids.map((id) => ({ id })), "Mass restore errors", options, ({ id }, opts) => this.restore(id, opts));
         }
-        this.checkReadOptions(options);
         const message = "Mass restore errors";
-        return this.executeSqlTransaction(async (tx) => {
-            const opts = {
-                ...options,
-                transaction: tx,
-                withDeleted: true,
-                onlyDeleted: false,
-            };
-            const hooks = options?.hooks ?? {};
-            const unique = this.uniqueIds(ids);
-            if (unique.length === 0)
-                return [];
-            await this.assertAllExist(tx, unique, opts, message);
-            if (!hooks.skipBefore) {
-                await this.eachItem(unique.map((id) => ({ id, run: () => this.beforeRestore(id) })), message);
-            }
-            await this.emitEvent("before", "restore", true, { ids: unique, transaction: tx }, options);
-            const set = this.softDeleteSet(null);
-            const restored = await this.runSet(tx, message, (sp) => this.updateWhereIn(sp, set, unique, opts), unique.map((id) => ({
-                id,
-                run: (sp) => this.updateWhereIn(sp, set, [id], opts),
-            })), "write");
-            this.assertAllWritten(unique, restored, message, options);
-            if (!hooks.skipAfter) {
+        return this.massWrite({
+            operation: "restore",
+            message,
+            options,
+            ids,
+            state: { withDeleted: true, onlyDeleted: false },
+            returnsRows: true,
+            prepare: (_opts, unique) => options?.hooks?.skipBefore
+                ? undefined
+                : unique.map((id) => ({ id, run: () => this.beforeRestore(id) })),
+            write: (tx, _prepared, opts, unique) => {
+                const set = this.softDeleteSet(null);
+                return this.runSet(tx, message, (sp) => this.updateWhereIn(sp, set, unique, opts), unique.map((id) => ({
+                    id,
+                    run: (sp) => this.updateWhereIn(sp, set, [id], opts),
+                })), "write");
+            },
+            after: async (restored) => {
                 for (const entity of restored)
                     await this.afterRestore(entity);
-            }
-            await this.emitEvent("after", "restore", true, { ids: unique, rows: restored, transaction: tx }, options);
-            await this.loadWriteRelations(tx, restored, options);
-            return this.inIdOrder(restored, ids);
-        }, options?.transaction);
+            },
+        });
     }
     async massDelete(ids, options) {
+        options = this.withScopeMemo(options);
         if (options?.bulkMode === "perItem") {
-            return this.massDeletePerItem(ids, options);
+            await this.eachInSavepoint(ids.map((id) => ({ id })), "Mass delete errors", options, ({ id }, opts) => this.delete(id, opts), "delete");
+            return true;
         }
         const message = "Mass delete errors";
-        return this.executeSqlTransaction(async (tx) => {
-            const opts = { ...options, transaction: tx };
-            const hooks = options?.hooks ?? {};
-            const unique = this.uniqueIds(ids);
-            if (unique.length === 0)
-                return true;
-            await this.assertAllExist(tx, unique, opts, message);
-            if (!hooks.skipBefore) {
-                await this.eachItem(unique.map((id) => ({ id, run: () => this.beforeDelete(id) })), message);
-            }
-            await this.emitEvent("before", "delete", true, { ids: unique, transaction: tx }, options);
-            const written = await this.runSet(tx, message, (sp) => this.runKeyed(sp.delete(this.config.table).where(this.writeWhere(unique, opts)), unique), unique.map((id) => ({
-                id,
-                run: (sp) => sp.delete(this.config.table).where(this.writeWhere([id], opts)),
-            })), "delete");
-            this.assertAllWritten(unique, written, message, options);
-            if (!hooks.skipAfter) {
+        await this.massWrite({
+            operation: "delete",
+            message,
+            options,
+            ids,
+            returnsRows: false,
+            prepare: (_opts, unique) => options?.hooks?.skipBefore
+                ? undefined
+                : unique.map((id) => ({ id, run: () => this.beforeDelete(id) })),
+            write: (tx, _prepared, opts, unique) => {
+                const remove = (db, keys) => db.delete(this.config.table).where(this.writeWhere(keys, opts));
+                return this.runSet(tx, message, (sp) => this.runKeyed(remove(sp, unique), unique), unique.map((id) => ({ id, run: (sp) => remove(sp, [id]) })), "delete");
+            },
+            after: async (_written, unique) => {
                 for (const id of unique)
                     await this.afterDelete(id);
-            }
-            await this.emitEvent("after", "delete", true, { ids: unique, transaction: tx }, options);
-            return true;
-        }, options?.transaction);
+            },
+        });
+        return true;
     }
     async massForceDelete(ids, options) {
         return this.massDelete(ids, {
@@ -2446,12 +2656,16 @@ class SqlBaseCrudService {
         return item.index !== undefined ? { index: item.index } : { id: item.id };
     }
     async runSet(tx, message, statement, items, operation) {
+        const owned = this.ownedTransactions.has(tx);
         try {
-            return await this.savepoint(tx, statement);
+            return await (owned ? statement(tx) : this.savepoint(tx, statement));
         }
         catch (error) {
             if (error instanceof BindLimitException)
                 throw error;
+            if (owned) {
+                throw new DeferredDiagnosis(() => this.settleSet(message, error, items, operation));
+            }
             const failures = await this.diagnose(tx, items, operation);
             if (failures.length > 0) {
                 throw new crud_exceptions_1.BulkOperationException(message, failures);
@@ -2459,6 +2673,23 @@ class SqlBaseCrudService {
             throw this.toClientError(error, operation);
         }
     }
+    async settleSet(message, error, items, operation) {
+        let failures = [];
+        try {
+            await this.config.db.transaction(async (fresh) => {
+                failures = await this.diagnose(this.withBindLimit(fresh), items, operation);
+                throw ROLLBACK;
+            });
+        }
+        catch (thrown) {
+            if (thrown !== ROLLBACK)
+                throw thrown;
+        }
+        if (failures.length > 0) {
+            throw new crud_exceptions_1.BulkOperationException(message, failures);
+        }
+        throw this.toClientError(error, operation);
+    }
     async diagnose(tx, items, operation) {
         const failures = [];
         try {
@@ -2483,37 +2714,11 @@ class SqlBaseCrudService {
         }
         return failures;
     }
-    async massCreatePerItem(data, options) {
-        return this.executeSqlTransaction((tx) => this.eachItem(data.map((item, index) => ({
-            index,
-            run: () => this.savepoint(tx, (sp) => this.create(item, { ...options, transaction: sp })),
-        })), "Mass create errors"), options?.transaction);
-    }
-    async massUpdatePerItem(ids, data, options) {
-        return this.executeSqlTransaction((tx) => this.eachItem(ids.map((id) => ({
-            id,
-            run: () => this.savepoint(tx, (sp) => this.update(id, data, { ...options, transaction: sp })),
-        })), "Mass update errors"), options?.transaction);
-    }
-    async massSoftDeletePerItem(ids, options) {
-        await this.executeSqlTransaction((tx) => this.eachItem(ids.map((id) => ({
-            id,
-            run: () => this.savepoint(tx, (sp) => this.softDelete(id, { ...options, transaction: sp })),
-        })), "Mass soft delete errors"), options?.transaction);
-        return true;
-    }
-    async massRestorePerItem(ids, options) {
-        return this.executeSqlTransaction((tx) => this.eachItem(ids.map((id) => ({
-            id,
-            run: () => this.savepoint(tx, (sp) => this.restore(id, { ...options, transaction: sp })),
-        })), "Mass restore errors"), options?.transaction);
-    }
-    async massDeletePerItem(ids, options) {
-        await this.executeSqlTransaction((tx) => this.eachItem(ids.map((id) => ({
-            id,
-            run: () => this.savepoint(tx, (sp) => this.delete(id, { ...options, transaction: sp })),
-        })), "Mass delete errors", "delete"), options?.transaction);
-        return true;
+    eachInSavepoint(entries, message, options, call, operation = "write") {
+        return this.executeSqlTransaction((tx) => this.eachItem(entries.map((entry) => ({
+            ...entry,
+            run: () => this.savepoint(tx, (sp) => call(entry, { ...options, transaction: sp })),
+        })), message, operation), options?.transaction);
     }
     savepoint(tx, run) {
         return typeof tx?.transaction === "function"
@@ -2521,20 +2726,26 @@ class SqlBaseCrudService {
             : run(tx);
     }
     async exists(id, options) {
+        options = this.withScopeMemo(options);
+        this.checkReadOptions({ ...options, select: undefined });
         const entity = await this.find(id, {
             ...options,
+            relations: [],
+            counts: undefined,
             select: [this.config.primaryKey],
         });
         return !!entity;
     }
     async count(filters, options) {
+        options = this.withScopeMemo(options);
         this.checkReadOptions(options);
         const db = this.dbFor(options?.transaction);
         const { conditions, relations: filterRelations } = this.listConditions(filters, db, options);
         const result = await this.runRead(this.buildCountQuery(db, conditions, filterRelations, options));
-        return parseInt(result[0]?.count?.toString() || "0", 10);
+        return this.parseCount(result);
     }
     async countBy(column, filters, options) {
+        options = this.withScopeMemo(options);
         this.checkReadOptions(options);
         const db = this.dbFor(options?.transaction);
         const spec = this.resolveGroupColumn(column, options);
@@ -2567,10 +2778,7 @@ class SqlBaseCrudService {
         }
         else {
             const name = key.slice(0, dot);
-            const relations = this.config.relations || {};
-            const relation = Object.hasOwn(relations, name)
-                ? relations[name]
-                : undefined;
+            const relation = this.relationNamed(name);
             const column = relation && !this.isCollection(relation) && relation.localKey
                 ? this.columnOf(relation.table, key.slice(dot + 1))
                 : undefined;
@@ -2603,27 +2811,9 @@ class SqlBaseCrudService {
         return keys.length > 0 ? Array.from(new Set([...base, ...keys])) : base;
     }
     async loadCounts(db, rows, counts, options) {
-        const names = this.countNames(counts);
-        if (names.length === 0 || !Array.isArray(rows))
+        if (this.countNames(counts).length === 0 || !Array.isArray(rows))
             return;
-        const relations = this.config.relations || {};
-        const plan = names.map((name) => {
-            const relation = Object.hasOwn(relations, name)
-                ? relations[name]
-                : undefined;
-            if (!relation) {
-                throw new common_1.BadRequestException(`Unknown relation to count: ${name}`);
-            }
-            if (!this.isCollection(relation)) {
-                throw new common_1.BadRequestException(`Cannot count "${name}": only a has-many or many-to-many relation has a count`);
-            }
-            const filter = !Array.isArray(counts) && (0, merge_config_1.isPlainObject)(counts?.[name])
-                ? counts?.[name]
-                : undefined;
-            if (filter)
-                (0, query_parser_1.assertFilterDepth)(filter);
-            return { name, relation, filter };
-        });
+        const plan = this.countPlan(counts);
         const hosts = rows.filter((row) => row && typeof row === "object");
         for (const host of hosts)
             host._count = {};
@@ -2634,7 +2824,7 @@ class SqlBaseCrudService {
             const ids = Array.from(new Set(hosts.map((host) => host[parentKey]).filter((v) => v != null)));
             const totals = new Map();
             if (ids.length > 0) {
-                const result = await this.runRead(this.countQuery(db, relation, ids, name, filter, options));
+                const result = await this.inChunks(db, ids, (chunk) => this.runRead(this.countQuery(db, relation, chunk, name, filter, options)));
                 for (const row of result) {
                     totals.set(String(row[COUNT_KEY]), Number(row.count));
                 }
@@ -2644,6 +2834,23 @@ class SqlBaseCrudService {
             }
         }));
     }
+    countPlan(counts) {
+        return this.countNames(counts).map((name) => {
+            const relation = this.relationNamed(name);
+            if (!relation) {
+                throw new common_1.BadRequestException(`Unknown relation to count: ${name}`);
+            }
+            if (!this.isCollection(relation)) {
+                throw new common_1.BadRequestException(`Cannot count "${name}": only a has-many or many-to-many relation has a count`);
+            }
+            const filter = !Array.isArray(counts) && (0, merge_config_1.isPlainObject)(counts?.[name])
+                ? counts?.[name]
+                : undefined;
+            if (filter)
+                (0, query_parser_1.assertFilterDepth)(filter);
+            return { name, relation, filter };
+        });
+    }
     countQuery(db, relation, ids, name, filter, options) {
         const target = relation.table;
         const conditions = [];
@@ -2660,12 +2867,7 @@ class SqlBaseCrudService {
         const total = (0, drizzle_orm_1.sql) `count(*)`;
         if (this.relationType(relation) === "manyToMany") {
             const joinLocal = relation.through[relation.throughLocalKey];
-            const joinForeign = relation.through[relation.throughForeignKey];
-            const referenced = target[relation.references ?? "id"];
-            return db
-                .select({ [COUNT_KEY]: joinLocal, count: total })
-                .from(relation.through)
-                .innerJoin(target, (0, drizzle_orm_1.eq)(joinForeign, referenced))
+            return this.selectThrough(db, { [COUNT_KEY]: joinLocal, count: total }, relation)
                 .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.inArray)(joinLocal, ids), ...conditions))
                 .groupBy(joinLocal);
         }
@@ -2718,11 +2920,7 @@ class SqlBaseCrudService {
             const joinForeign = relation.through?.[relation.throughForeignKey ?? ""];
             if (!referenced || !joinForeign)
                 return undefined;
-            subquery = db
-                .select({ value: key })
-                .from(relation.through)
-                .innerJoin(target, (0, drizzle_orm_1.eq)(joinForeign, referenced))
-                .where((0, drizzle_orm_1.and)(...conditions));
+            subquery = this.selectThrough(db, { value: key }, relation).where((0, drizzle_orm_1.and)(...conditions));
         }
         else {
             subquery = db
@@ -2750,11 +2948,7 @@ class SqlBaseCrudService {
         let subquery;
         if (this.relationType(relation) === "manyToMany") {
             const through = subqueryAlias(relation.through);
-            subquery = db
-                .select({ one: (0, drizzle_orm_1.sql) `1` })
-                .from(through)
-                .innerJoin(target, (0, drizzle_orm_1.eq)(through[relation.throughForeignKey], target[relation.references ?? "id"]))
-                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(through[relation.throughLocalKey], host.table[parentKey]), ...conditions));
+            subquery = this.selectThrough(db, { one: (0, drizzle_orm_1.sql) `1` }, relation, target, through).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(through[relation.throughLocalKey], host.table[parentKey]), ...conditions));
         }
         else {
             subquery = db
@@ -3069,8 +3263,21 @@ class SqlBaseCrudService {
         const run = (tx) => operation(this.withBindLimit(tx));
         if (existingTransaction)
             return run(existingTransaction);
-        return this.config.db.transaction(run);
+        try {
+            return await this.config.db.transaction((tx) => {
+                const view = this.withBindLimit(tx);
+                if (view && typeof view === "object")
+                    this.ownedTransactions.add(view);
+                return operation(view);
+            });
+        }
+        catch (error) {
+            if (error instanceof DeferredDiagnosis)
+                return error.settle();
+            throw error;
+        }
     }
+    ownedTransactions = new WeakSet();
     assertTransactions(db) {
         if (this.config.dialect !== "sqlite")
             return;
@@ -3090,6 +3297,7 @@ class SqlBaseCrudService {
         }
     }
     async fullTextSearch(searchTerm, searchColumns, pagination, options) {
+        options = this.withScopeMemo(options);
         if (this.config.dialect !== "postgresql") {
             throw new common_1.BadRequestException("Full-text search only supported in PostgreSQL");
         }
@@ -3128,12 +3336,9 @@ class SqlBaseCrudService {
             .offset(offset);
         const countQuery = this.buildCountQuery(plan.db, conditions, plan.filterRelations, readOptions);
         const [fetched, totalResult] = await this.runRead(Promise.all([dataQuery, countQuery]));
-        const total = parseInt(totalResult[0]?.count?.toString() || "0", 10);
+        const total = this.parseCount(totalResult);
         const rows = this.normalizeRelations(fetched, plan.joined.map((node) => node.name));
-        await Promise.all([
-            this.loadRelations(plan.db, rows, plan.nodes, plan.selection, undefined, readOptions),
-            this.loadCounts(plan.db, rows, readOptions.counts, readOptions),
-        ]);
+        await this.hydrate(plan.db, rows, plan.nodes, plan.selection, readOptions);
         return { data: rows, total, page, limit };
     }
 }