@avytrix/nestjs-drizzle-crud 3.8.1 → 3.8.2

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

@@ -11,7 +11,8 @@ const query_parser_1 = require("../utils/query-parser");
 const JOIN_KEY = "__crudJoinKey";
 const CURSOR_KEY = "__crudCursor";
 const SCOPE_MEMO = Symbol("scopeMemo");
-let fingerprintTag = 0;
+const fingerprintTags = new WeakMap();
+let fingerprintCount = 0;
 const ROLLBACK = Symbol("rollback");
 class DeferredDiagnosis {
     settle;
@@ -128,15 +129,38 @@ class SqlBaseCrudService {
         return /(Text|VarChar|Varchar|Char)$/.test(column?.columnType ?? "");
     }
     coerceFilterValue(column, value) {
-        if (column?.dataType !== "date" || value instanceof Date)
+        if (column?.dataType !== "date")
             return value;
-        if (typeof value === "string" || typeof value === "number") {
-            const date = new Date(value);
-            if (!Number.isNaN(date.getTime()))
-                return date;
-        }
+        const date = this.toDate(value);
+        if (date)
+            return date;
         throw new common_1.BadRequestException(`Invalid date filter value: ${value}`);
     }
+    toDate(value) {
+        const date = value instanceof Date
+            ? value
+            : typeof value === "string" || typeof value === "number"
+                ? new Date(value)
+                : undefined;
+        return date && !Number.isNaN(date.getTime()) ? date : undefined;
+    }
+    coerceDates(table, row) {
+        for (const [key, value] of Object.entries(row)) {
+            const column = this.columnOf(table, key);
+            if (column?.dataType !== "date" ||
+                !(typeof value === "string" ||
+                    typeof value === "number" ||
+                    value instanceof Date)) {
+                continue;
+            }
+            const date = this.toDate(value);
+            if (!date) {
+                throw new crud_exceptions_1.ValidationFailedException(`a date or time value has an invalid format: ${column.name ?? key}`);
+            }
+            row[key] = date;
+        }
+        return row;
+    }
     static ALLOWLIST_LABELS = {
         filterableColumns: "Filtering on",
         sortableColumns: "Sorting by",
@@ -194,7 +218,8 @@ class SqlBaseCrudService {
         if (!scope || options?.skipScope)
             return null;
         const context = options?.context ?? crud_context_1.CrudContext.current();
-        const memo = options?.[SCOPE_MEMO];
+        const found = options?.[SCOPE_MEMO];
+        const memo = found?.ended ? undefined : found;
         const mine = memo?.get(this);
         if (mine?.has(context))
             return mine.get(context);
@@ -207,12 +232,23 @@ class SqlBaseCrudService {
         return checked;
     }
     withScopeMemo(options) {
-        if (typeof this.config.scope !== "function" ||
-            options?.[SCOPE_MEMO]) {
+        const memo = options?.[SCOPE_MEMO];
+        if (typeof this.config.scope !== "function" || (memo && !memo.ended)) {
             return options;
         }
         return { ...options, [SCOPE_MEMO]: new Map() };
     }
+    async scopedCall(options, run) {
+        const scoped = this.withScopeMemo(options);
+        const started = scoped === options ? undefined : scoped[SCOPE_MEMO];
+        try {
+            return await run(scoped);
+        }
+        finally {
+            if (started)
+                started.ended = true;
+        }
+    }
     checkScope(values) {
         if (values === null)
             return null;
@@ -330,8 +366,9 @@ class SqlBaseCrudService {
                 query = dialect.sqlToQuery(...args);
             }
             catch (error) {
-                if (error instanceof RangeError)
+                if (error instanceof RangeError && /call stack/i.test(error.message)) {
                     throw tooMany(`more than ${limit}`);
+                }
                 throw error;
             }
             const count = query?.params?.length ?? 0;
@@ -1247,14 +1284,16 @@ 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);
+        return this.scopedCall(options, async (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);
+        return this.scopedCall(options, async (options) => {
+            this.checkReadOptions(options);
+            return this.findFirst(this.buildWhereConditionsFromPartial(where), options);
+        });
     }
     async findFirst(conditions, options) {
         const first = await this.readFirst(conditions, options);
@@ -1335,105 +1374,107 @@ 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);
-        const plan = this.planList(filters, sortBy, sortOrder, options);
-        let dataQuery = this.startSelect(plan.db, plan.baseSelect, plan.joined, plan.joinRelations.length > 0, plan.selection);
-        dataQuery = this.applyJoins(dataQuery, plan.joinRelations, options);
-        if (plan.conditions.length > 0) {
-            dataQuery = dataQuery.where((0, drizzle_orm_1.and)(...plan.conditions));
-        }
-        if (plan.sort.length > 0) {
-            dataQuery = dataQuery.orderBy(...plan.sort.map((spec) => this.orderOf(spec)));
-        }
-        dataQuery = dataQuery
-            .limit(withCount ? safeLimit : safeLimit + 1)
-            .offset(offset);
-        dataQuery = this.applyLock(dataQuery, options);
-        const countQuery = withCount
-            ? this.buildCountQuery(plan.db, plan.conditions, plan.filterRelations, options)
-            : Promise.resolve(undefined);
-        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 this.hydrate(plan.db, rows, plan.nodes, plan.selection, options);
-        if (!withCount) {
+        return this.scopedCall(options, async (options) => {
+            const { sortBy, sortOrder = "asc" } = pagination || {};
+            const withCount = pagination?.withCount !== false;
+            const { page, limit: safeLimit, offset, } = this.resolvePagination(pagination?.page, pagination?.limit);
+            const plan = this.planList(filters, sortBy, sortOrder, options);
+            let dataQuery = this.startSelect(plan.db, plan.baseSelect, plan.joined, plan.joinRelations.length > 0, plan.selection);
+            dataQuery = this.applyJoins(dataQuery, plan.joinRelations, options);
+            if (plan.conditions.length > 0) {
+                dataQuery = dataQuery.where((0, drizzle_orm_1.and)(...plan.conditions));
+            }
+            if (plan.sort.length > 0) {
+                dataQuery = dataQuery.orderBy(...plan.sort.map((spec) => this.orderOf(spec)));
+            }
+            dataQuery = dataQuery
+                .limit(withCount ? safeLimit : safeLimit + 1)
+                .offset(offset);
+            dataQuery = this.applyLock(dataQuery, options);
+            const countQuery = withCount
+                ? this.buildCountQuery(plan.db, plan.conditions, plan.filterRelations, options)
+                : Promise.resolve(undefined);
+            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 this.hydrate(plan.db, rows, plan.nodes, plan.selection, options);
+            if (!withCount) {
+                return {
+                    data: rows,
+                    total: null,
+                    page,
+                    limit: safeLimit,
+                    hasMore: fetched.length > safeLimit,
+                };
+            }
             return {
                 data: rows,
-                total: null,
+                total: this.parseCount(totalResult),
                 page,
                 limit: safeLimit,
-                hasMore: fetched.length > safeLimit,
             };
-        }
-        return {
-            data: rows,
-            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);
-        const signature = plan.sort
-            .map((spec) => `${spec.key}:${spec.order}`)
-            .join(",");
-        const cursor = pagination?.cursor ?? pagination?.after;
-        const conditions = [...plan.conditions];
-        if (cursor !== undefined && cursor !== null && cursor !== "") {
-            if (typeof cursor !== "string") {
-                throw new common_1.BadRequestException("Invalid cursor");
-            }
-            const values = (0, cursor_1.decodeCursor)(cursor, signature, plan.sort.length);
-            conditions.push(this.keysetCondition(plan.sort, values));
-        }
-        const fields = this.buildSelection(plan.baseSelect, plan.joined, plan.selection);
-        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}`;
+        return this.scopedCall(options, async (options) => {
+            const { sortBy, sortOrder = "asc", count = false } = pagination || {};
+            const { limit } = this.resolvePagination(1, pagination?.limit);
+            const plan = this.planList(filters, sortBy, sortOrder, options);
+            const signature = plan.sort
+                .map((spec) => `${spec.key}:${spec.order}`)
+                .join(",");
+            const cursor = pagination?.cursor ?? pagination?.after;
+            const conditions = [...plan.conditions];
+            if (cursor !== undefined && cursor !== null && cursor !== "") {
+                if (typeof cursor !== "string") {
+                    throw new common_1.BadRequestException("Invalid cursor");
+                }
+                const values = (0, cursor_1.decodeCursor)(cursor, signature, plan.sort.length);
+                conditions.push(this.keysetCondition(plan.sort, values));
+            }
+            const fields = this.buildSelection(plan.baseSelect, plan.joined, plan.selection);
+            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)
+                dataQuery = dataQuery.where((0, drizzle_orm_1.and)(...conditions));
+            dataQuery = dataQuery
+                .orderBy(...plan.sort.map((spec) => this.orderOf(spec)))
+                .limit(limit + 1);
+            dataQuery = this.applyLock(dataQuery, options);
+            const [data, totalResult] = await this.runRead(Promise.all([
+                dataQuery,
+                count
+                    ? this.buildCountQuery(plan.db, plan.conditions, plan.filterRelations, options)
+                    : Promise.resolve(undefined),
+            ]));
+            const page = data.slice(0, limit);
+            const last = page[page.length - 1];
+            const nextCursor = data.length > limit && last
+                ? (0, cursor_1.encodeCursor)(cursorKeys.map((key) => last[key]), signature)
+                : null;
+            for (const row of page) {
+                for (const key of hidden)
+                    delete row[key];
+            }
+            const rows = this.normalizeRelations(page, plan.joined.map((node) => node.name));
+            await this.hydrate(plan.db, rows, plan.nodes, plan.selection, options);
+            const out = { data: rows, limit, nextCursor };
+            if (count) {
+                out.total = this.parseCount(totalResult);
+            }
+            return out;
         });
-        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)
-            dataQuery = dataQuery.where((0, drizzle_orm_1.and)(...conditions));
-        dataQuery = dataQuery
-            .orderBy(...plan.sort.map((spec) => this.orderOf(spec)))
-            .limit(limit + 1);
-        dataQuery = this.applyLock(dataQuery, options);
-        const [data, totalResult] = await this.runRead(Promise.all([
-            dataQuery,
-            count
-                ? this.buildCountQuery(plan.db, plan.conditions, plan.filterRelations, options)
-                : Promise.resolve(undefined),
-        ]));
-        const page = data.slice(0, limit);
-        const last = page[page.length - 1];
-        const nextCursor = data.length > limit && last
-            ? (0, cursor_1.encodeCursor)(cursorKeys.map((key) => last[key]), signature)
-            : null;
-        for (const row of page) {
-            for (const key of hidden)
-                delete row[key];
-        }
-        const rows = this.normalizeRelations(page, plan.joined.map((node) => node.name));
-        await this.hydrate(plan.db, rows, plan.nodes, plan.selection, options);
-        const out = { data: rows, limit, nextCursor };
-        if (count) {
-            out.total = this.parseCount(totalResult);
-        }
-        return out;
     }
     cursorField(column) {
         if (column?.dataType !== "date")
@@ -1564,10 +1605,13 @@ class SqlBaseCrudService {
         }
     }
     async writeThenLoad(operation, options, write) {
-        const late = this.loadsAfterCommit(operation, options);
-        const rows = await this.executeSqlTransaction((tx) => write(tx, (inTx, written) => late
-            ? Promise.resolve()
-            : this.loadWriteRelations(inTx, written, options)), options?.transaction);
+        let late = this.loadsAfterCommit(operation, options);
+        const rows = await this.executeSqlTransaction((tx) => write(tx, (inTx, written, inside = false) => {
+            if (late && !inside)
+                return Promise.resolve();
+            late = false;
+            return this.loadWriteRelations(inTx, written, options);
+        }), options?.transaction);
         if (late)
             await this.loadWriteRelations(this.dbFor(), rows, options);
         return rows;
@@ -1596,7 +1640,7 @@ class SqlBaseCrudService {
         const version = this.config.versionColumn;
         if (version)
             delete mapped[version];
-        const entityData = this.filterWritable(mapped, "create", options);
+        const entityData = this.coerceDates(this.config.table, this.filterWritable(mapped, "create", options));
         const now = new Date();
         if (this.config.timestamps?.createdAt)
             entityData[this.config.timestamps.createdAt] = now;
@@ -1626,35 +1670,36 @@ 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);
-        const nested = this.takeNested(entityData, options);
-        const db = this.dbFor(transaction);
-        await this.emitEvent("before", "create", false, { input: data, transaction }, options);
-        try {
-            await this.assertKeysInScope(db, entityData, options, nested.map((entry) => entry.name));
-            const createdEntity = nested.length === 0
-                ? await this.insertOne(db, entityData, options)
-                : await this.executeSqlTransaction((tx) => this.insertNested(tx, entityData, nested, {
-                    ...options,
-                    transaction: tx,
-                }), transaction);
-            if (!hooks.skipAfter)
-                await this.afterCreate(createdEntity);
-            await this.emitEvent("after", "create", false, {
-                ids: this.idsOf([createdEntity]),
-                input: data,
-                rows: [createdEntity],
-                transaction,
-            }, options);
-            await this.loadWriteRelations(db, [createdEntity], options);
-            return createdEntity;
-        }
-        catch (error) {
-            throw this.toClientError(error, "write");
-        }
+        return this.scopedCall(options, async (options) => {
+            const { transaction, hooks = {} } = options || {};
+            this.checkReadOptions(options);
+            const entityData = await this.prepareCreate(data, options);
+            const nested = this.takeNested(entityData, options);
+            const db = this.dbFor(transaction);
+            await this.emitEvent("before", "create", false, { input: data, transaction }, options);
+            try {
+                await this.assertKeysInScope(db, entityData, options, nested.map((entry) => entry.name));
+                const createdEntity = nested.length === 0
+                    ? await this.insertOne(db, entityData, options)
+                    : await this.executeSqlTransaction((tx) => this.insertNested(tx, entityData, nested, {
+                        ...options,
+                        transaction: tx,
+                    }), transaction);
+                if (!hooks.skipAfter)
+                    await this.afterCreate(createdEntity);
+                await this.emitEvent("after", "create", false, {
+                    ids: this.idsOf([createdEntity]),
+                    input: data,
+                    rows: [createdEntity],
+                    transaction,
+                }, options);
+                await this.loadWriteRelations(db, [createdEntity], options);
+                return createdEntity;
+            }
+            catch (error) {
+                throw this.toClientError(error, "write");
+            }
+        });
     }
     takeNested(entity, options) {
         const allowed = this.config.writableRelations;
@@ -1760,7 +1805,7 @@ class SqlBaseCrudService {
             if (this.columnOf(table, key))
                 out[key] = item;
         }
-        return out;
+        return this.coerceDates(table, out);
     }
     async keysOutsideScope(db, rows, options, skip = [], owner = {
         table: this.config.table,
@@ -1779,26 +1824,29 @@ class SqlBaseCrudService {
             const referenced = relation.table[relation.references ?? "id"];
             if (scope.length === 0 || !referenced)
                 continue;
-            const keys = this.uniqueValues(rows.map((row) => row[local]).filter((value) => value != null), referenced);
+            const keys = this.distinct(rows.map((row) => row[local]).filter((value) => value != null));
             if (keys.length === 0)
                 continue;
             checks.push({
                 local,
-                referenced,
-                query: db
-                    .select({ id: referenced })
-                    .from(relation.table)
-                    .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.inArray)(referenced, keys), ...scope)),
+                keys,
+                query: this.matchKeys(db, relation.table, referenced, keys, scope),
             });
         }
-        const found = await Promise.all(checks.map((check) => check.query));
-        checks.forEach(({ local, referenced }, i) => {
-            const present = new Set(found[i].map((row) => this.valueKey(row.id, referenced)));
+        let found;
+        try {
+            found = await Promise.all(checks.map((check) => check.query));
+        }
+        catch (error) {
+            throw this.toClientError(error, "write");
+        }
+        checks.forEach(({ local, keys }, i) => {
+            const matched = found[i];
+            const present = new Set(keys.filter((_, at) => matched.has(at)));
             rows.forEach((row, index) => {
                 const value = row[local];
-                if (value == null || present.has(this.valueKey(value, referenced))) {
+                if (value == null || present.has(value))
                     return;
-                }
                 if (!failures.has(index)) {
                     failures.set(index, this.missingParentException(local, owner.table));
                 }
@@ -1838,21 +1886,14 @@ class SqlBaseCrudService {
     async linkTargets(tx, relation, parentValue, ids, options, fresh = false) {
         const target = relation.table;
         const referenced = target[relation.references ?? "id"];
-        const wanted = this.uniqueValues(ids, referenced);
+        const wanted = this.distinct(ids);
         if (wanted.length === 0)
             return;
         const through = relation.through;
         const local = through[relation.throughLocalKey];
         const foreign = through[relation.throughForeignKey];
-        const conditions = [(0, drizzle_orm_1.inArray)(referenced, wanted)];
-        conditions.push(...this.relatedRowScope(target, options));
-        const found = await tx
-            .select({ id: referenced })
-            .from(target)
-            .where((0, drizzle_orm_1.and)(...conditions));
-        const key = (value) => this.valueKey(value, referenced);
-        const present = new Set(found.map((row) => key(row.id)));
-        const missing = wanted.filter((id) => !present.has(key(id)));
+        const found = await this.matchKeys(tx, target, referenced, wanted, this.relatedRowScope(target, options));
+        const missing = wanted.filter((_, at) => !found.has(at));
         if (missing.length > 0) {
             const name = this.tableName(target);
             throw new crud_exceptions_1.BulkOperationException("Unknown related ids", missing.map((id) => ({
@@ -1860,14 +1901,13 @@ class SqlBaseCrudService {
                 error: new crud_exceptions_1.EntityNotFoundException(name, id),
             })));
         }
+        const stored = this.distinct(wanted.map((_, at) => found.get(at)));
         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) => key(row.id)));
-        const add = wanted.filter((id) => !already.has(key(id)));
+            ? new Map()
+            : await this.matchKeys(tx, through, foreign, stored, [
+                (0, drizzle_orm_1.eq)(local, parentValue),
+            ]);
+        const add = stored.filter((_, at) => !linked.has(at));
         if (add.length > 0) {
             await tx.insert(through).values(add.map((id) => ({
                 [relation.throughLocalKey]: parentValue,
@@ -1876,16 +1916,19 @@ class SqlBaseCrudService {
         }
     }
     async attach(id, relation, relatedIds, options) {
-        options = this.withScopeMemo(options);
-        return this.changeLinks("attach", id, relation, relatedIds, options);
+        return this.scopedCall(options, async (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);
+        return this.scopedCall(options, async (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);
+        return this.scopedCall(options, async (options) => {
+            return this.changeLinks("sync", id, relation, relatedIds, options);
+        });
     }
     async changeLinks(operation, id, name, relatedIds, options) {
         const relation = this.relationNamed(name);
@@ -1905,7 +1948,7 @@ class SqlBaseCrudService {
             throw new common_1.BadRequestException(`${operation} takes an array of ids`);
         }
         this.checkReadOptions(options);
-        const ids = this.uniqueValues(relatedIds ?? [], relation.table[relation.references ?? "id"]);
+        const ids = this.distinct(relatedIds ?? []);
         const parentKey = this.parentKeyOf(relation);
         return this.executeSqlTransaction(async (tx) => {
             const opts = { ...options, transaction: tx };
@@ -1955,15 +1998,64 @@ class SqlBaseCrudService {
             ? key.toLowerCase()
             : key;
     }
-    uniqueValues(values, column) {
-        const seen = new Set();
-        return values.filter((value) => {
-            const key = this.valueKey(value, column);
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
+    distinct(values) {
+        return Array.from(new Set(values));
+    }
+    async matchKeys(db, table, column, values, conditions) {
+        const input = this.keyInput(column, values);
+        const rows = await db
+            .select({ at: input.at, key: column })
+            .from(table)
+            .innerJoin(input.list, (0, drizzle_orm_1.eq)(column, input.value))
+            .where((0, drizzle_orm_1.and)(...conditions));
+        return new Map(rows.map((row) => [Number(row.at), row.key]));
+    }
+    keyInput(column, values) {
+        const params = values.map((value) => drizzle_orm_1.sql.param(value, column));
+        if (this.config.dialect === "mysql") {
+            const rows = values.map((_, at) => (0, drizzle_orm_1.sql) `row(${drizzle_orm_1.sql.raw(String(at))})`);
+            const picked = (0, drizzle_orm_1.sql) `elt(input.column_0 + 1, ${drizzle_orm_1.sql.join(params, (0, drizzle_orm_1.sql) `, `)})`;
+            const cast = this.mysqlKeyCast(column);
+            return {
+                list: (0, drizzle_orm_1.sql) `(values ${drizzle_orm_1.sql.join(rows, (0, drizzle_orm_1.sql) `, `)}) as input`,
+                at: (0, drizzle_orm_1.sql) `input.column_0`,
+                value: cast ? (0, drizzle_orm_1.sql) `cast(${picked} as ${drizzle_orm_1.sql.raw(cast)})` : picked,
+            };
+        }
+        const type = this.config.dialect === "postgresql" && this.pgKeyType(column);
+        const rows = params.map((param, at) => (0, drizzle_orm_1.sql) `(${drizzle_orm_1.sql.raw(String(at))}, ${type ? (0, drizzle_orm_1.sql) `cast(${param} as ${type})` : param})`);
+        return {
+            list: (0, drizzle_orm_1.sql) `(values ${drizzle_orm_1.sql.join(rows, (0, drizzle_orm_1.sql) `, `)}) as input`,
+            at: (0, drizzle_orm_1.sql) `input.column1`,
+            value: (0, drizzle_orm_1.sql) `input.column2`,
+        };
+    }
+    mysqlKeyCast(column) {
+        const type = String(column?.getSQLType?.() ?? "").toLowerCase();
+        if (type === "serial")
+            return "unsigned";
+        if (/^(tiny|small|medium|big)?int\b/.test(type)) {
+            return type.includes("unsigned") ? "unsigned" : "signed";
+        }
+        const decimal = type.match(/^decimal(\(\d+(?:,\d+)?\))?/);
+        if (decimal)
+            return `decimal${decimal[1] ?? ""}`;
+        return undefined;
+    }
+    pgKeyType(column) {
+        const pgEnum = column.enum;
+        if (pgEnum?.enumName) {
+            return pgEnum.schema
+                ? (0, drizzle_orm_1.sql) `${drizzle_orm_1.sql.identifier(pgEnum.schema)}.${drizzle_orm_1.sql.identifier(pgEnum.enumName)}`
+                : (0, drizzle_orm_1.sql) `${drizzle_orm_1.sql.identifier(pgEnum.enumName)}`;
+        }
+        const type = column.getSQLType();
+        const serials = {
+            serial: "integer",
+            bigserial: "bigint",
+            smallserial: "smallint",
+        };
+        return drizzle_orm_1.sql.raw(serials[type] ?? type);
     }
     tableName(table) {
         try {
@@ -1980,7 +2072,7 @@ class SqlBaseCrudService {
         for (const key of Object.keys(this.resolveScope(options) ?? {})) {
             delete mapped[key];
         }
-        const entityData = this.filterWritable(mapped, "update", options);
+        const entityData = this.coerceDates(this.config.table, this.filterWritable(mapped, "update", options));
         const settable = Object.keys(entityData).filter((key) => entityData[key] !== undefined &&
             !!this.columnOf(this.config.table, key));
         if (settable.length === 0) {
@@ -1989,45 +2081,49 @@ 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 guarded = !this.skipsGuard(options, "validateUpdate", "mapUpdateDtoToEntity", "prepareUpdate", ...(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.guardOnError(guarded, id, opts, () => this.assertKeysInScope(db, entityData, opts));
-            const [updatedEntity] = await this.guardOnError(guarded || !!transaction, id, opts, () => this.updateWhereIn(db, this.withVersionBump(entityData), [id], opts, this.softDeleteScope(opts)));
-            if (!updatedEntity) {
+        return this.scopedCall(options, async (options) => {
+            const { transaction, hooks = {} } = options || {};
+            this.checkReadOptions(options);
+            const expected = this.expectedVersionOf(data, options);
+            const opts = {
+                ...options,
+                expectedVersion: expected,
+            };
+            const guarded = !this.skipsGuard(options, "validateUpdate", "mapUpdateDtoToEntity", "prepareUpdate", ...(hooks.skipBefore ? [] : ["beforeUpdate"]));
+            if (guarded)
                 await this.guardRow(id, opts);
-                if (expected !== undefined) {
-                    throw new crud_exceptions_1.StaleVersionException(this.getEntityName(), id);
+            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.guardOnError(guarded || !!transaction, id, opts, () => this.assertKeysInScope(db, entityData, opts));
+                const [updatedEntity] = await this.guardOnError(guarded || !!transaction, id, opts, () => 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);
+                    }
+                    throw new Error("Failed to update entity");
                 }
-                throw new Error("Failed to update entity");
+                if (!hooks.skipAfter)
+                    await this.afterUpdate(updatedEntity);
+                await this.emitEvent("after", "update", false, { ids: [id], input: data, rows: [updatedEntity], transaction }, options);
+                await this.loadWriteRelations(db, [updatedEntity], options);
+                return updatedEntity;
             }
-            if (!hooks.skipAfter)
-                await this.afterUpdate(updatedEntity);
-            await this.emitEvent("after", "update", false, { ids: [id], input: data, rows: [updatedEntity], transaction }, options);
-            await this.loadWriteRelations(db, [updatedEntity], options);
-            return updatedEntity;
-        }
-        catch (error) {
-            throw this.toClientError(error, "write");
-        }
+            catch (error) {
+                throw this.toClientError(error, "write");
+            }
+        });
     }
     async updateWhereIn(db, set, ids, options, extra) {
         const where = this.writeWhere(ids, options);
@@ -2097,27 +2193,28 @@ class SqlBaseCrudService {
         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");
-        }
-        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),
+        return this.scopedCall(options, async (options) => {
+            if (!this.config.softDelete?.enabled) {
+                throw new common_1.BadRequestException("Soft delete is not enabled for this entity");
+            }
+            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) {
@@ -2129,42 +2226,44 @@ 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 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],
+        return this.scopedCall(options, async (options) => {
+            if (!this.config.softDelete?.enabled) {
+                throw new common_1.BadRequestException("Soft delete is not enabled for this entity");
+            }
+            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],
+            });
+            await this.loadWriteRelations(this.dbFor(options?.transaction), [restored], options);
+            return restored;
         });
-        await this.loadWriteRelations(this.dbFor(options?.transaction), [restored], options);
-        return restored;
     }
     async delete(id, options) {
-        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",
+        return this.scopedCall(options, async (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) {
@@ -2175,46 +2274,48 @@ 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);
-        await this.emitEvent("before", "upsert", false, { input: data, transaction: options?.transaction }, options);
-        let row;
-        try {
-            await this.assertKeysInScope(db, entityData, options);
-            [row] = await this.upsertRows(db, [entityData], upsert, options);
-        }
-        catch (error) {
-            throw this.toClientError(error, "write");
-        }
-        if (!row) {
-            throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), this.conflictValue(entityData, upsert));
-        }
-        await this.emitEvent("after", "upsert", false, {
-            ids: this.idsOf([row]),
-            input: data,
-            rows: [row],
-            transaction: options?.transaction,
-        }, options);
-        await this.loadWriteRelations(db, [row], options);
-        return row;
+        return this.scopedCall(options, async (options) => {
+            this.checkReadOptions(options);
+            const entityData = await this.prepareCreate(data, options);
+            const db = this.dbFor(options?.transaction);
+            await this.emitEvent("before", "upsert", false, { input: data, transaction: options?.transaction }, options);
+            let row;
+            try {
+                await this.assertKeysInScope(db, entityData, options);
+                [row] = await this.upsertRows(db, [entityData], upsert, options);
+            }
+            catch (error) {
+                throw this.toClientError(error, "write");
+            }
+            if (!row) {
+                throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), this.conflictValue(entityData, upsert));
+            }
+            await this.emitEvent("after", "upsert", false, {
+                ids: this.idsOf([row]),
+                input: data,
+                rows: [row],
+                transaction: options?.transaction,
+            }, options);
+            await this.loadWriteRelations(db, [row], options);
+            return row;
+        });
     }
     async massUpsert(data, upsert = {}, options) {
-        options = this.withScopeMemo(options);
-        const message = "Mass upsert errors";
-        return this.massWrite({
-            operation: "upsert",
-            message,
-            options,
-            input: data,
-            returnsRows: true,
-            prepare: (opts) => data.map((item, index) => ({
-                index,
-                run: () => this.prepareCreate(item, opts),
-            })),
-            keys: true,
-            write: (tx, rows, opts) => this.upsertSet(tx, rows, upsert, opts, message),
+        return this.scopedCall(options, async (options) => {
+            const message = "Mass upsert errors";
+            return this.massWrite({
+                operation: "upsert",
+                message,
+                options,
+                input: data,
+                returnsRows: true,
+                prepare: (opts) => data.map((item, index) => ({
+                    index,
+                    run: () => this.prepareCreate(item, opts),
+                })),
+                keys: true,
+                write: (tx, rows, opts) => this.upsertSet(tx, rows, upsert, opts, message),
+            });
         });
     }
     async upsertSet(tx, rows, upsert, opts, message) {
@@ -2369,8 +2470,9 @@ class SqlBaseCrudService {
                 ids: ids ? unique : this.idsOf(written),
                 rows: spec.returnsRows ? written : undefined,
             }, options);
-            if (spec.returnsRows)
-                await load(tx, written);
+            if (spec.returnsRows) {
+                await load(tx, written, prepared.some((row) => this.holdsSql(row)));
+            }
             return ids ? this.inIdOrder(written, ids) : written;
         };
         return spec.returnsRows
@@ -2378,30 +2480,31 @@ class SqlBaseCrudService {
             : this.executeSqlTransaction((tx) => body(tx, async () => { }), options?.transaction);
     }
     async massCreate(data, options) {
-        options = this.withScopeMemo(options);
-        if (options?.bulkMode === "perItem") {
-            return this.eachInSavepoint(data.map((item, index) => ({ index, item })), "Mass create errors", options, ({ item }, opts) => this.create(item, opts));
-        }
-        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),
-            })),
-            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"),
-            after: async (created) => {
-                for (const entity of created)
-                    await this.afterCreate(entity);
-            },
+        return this.scopedCall(options, async (options) => {
+            if (options?.bulkMode === "perItem") {
+                return this.eachInSavepoint(data.map((item, index) => ({ index, item })), "Mass create errors", options, ({ item }, opts) => this.create(item, opts));
+            }
+            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),
+                })),
+                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"),
+                after: async (created) => {
+                    for (const entity of created)
+                        await this.afterCreate(entity);
+                },
+            });
         });
     }
     async insertMany(db, rows, options) {
@@ -2451,35 +2554,36 @@ class SqlBaseCrudService {
         })));
     }
     async massUpdate(ids, data, options) {
-        options = this.withScopeMemo(options);
-        if (options?.bulkMode === "perItem") {
-            return this.eachInSavepoint(ids.map((id) => ({ id })), "Mass update errors", options, ({ id }, opts) => this.update(id, data, opts));
-        }
-        const message = "Mass update errors";
-        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 = skipBefore
-                        ? data
-                        : await this.beforeUpdate(id, data);
-                    return this.prepareUpdate(processed, opts);
+        return this.scopedCall(options, async (options) => {
+            if (options?.bulkMode === "perItem") {
+                return this.eachInSavepoint(ids.map((id) => ({ id })), "Mass update errors", options, ({ id }, opts) => this.update(id, data, opts));
+            }
+            const message = "Mass update errors";
+            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 = skipBefore
+                            ? data
+                            : await this.beforeUpdate(id, data);
+                        return this.prepareUpdate(processed, opts);
+                    },
+                })),
+                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);
                 },
-            })),
-            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) {
@@ -2520,99 +2624,105 @@ 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") {
-            await this.eachInSavepoint(ids.map((id) => ({ id })), "Mass soft delete errors", options, ({ id }, opts) => this.softDelete(id, opts));
+        return this.scopedCall(options, async (options) => {
+            if (!this.config.softDelete?.enabled)
+                throw new common_1.BadRequestException("Soft delete not enabled");
+            if (options?.bulkMode === "perItem") {
+                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";
+            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((0, drizzle_orm_1.and)(this.writeWhere(keys, opts), this.softDeleteScope(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);
+                },
+            });
             return true;
-        }
-        const message = "Mass soft delete errors";
-        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((0, drizzle_orm_1.and)(this.writeWhere(keys, opts), this.softDeleteScope(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);
-            },
         });
-        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.eachInSavepoint(ids.map((id) => ({ id })), "Mass restore errors", options, ({ id }, opts) => this.restore(id, opts));
-        }
-        const message = "Mass restore errors";
-        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);
-                const state = this.softDeleteScope(opts);
-                return this.runSet(tx, message, (sp) => this.updateWhereIn(sp, set, unique, opts, state), unique.map((id) => ({
-                    id,
-                    run: (sp) => this.updateWhereIn(sp, set, [id], opts, state),
-                })), "write");
-            },
-            after: async (restored) => {
-                for (const entity of restored)
-                    await this.afterRestore(entity);
-            },
+        return this.scopedCall(options, async (options) => {
+            if (!this.config.softDelete?.enabled)
+                throw new common_1.BadRequestException("Soft delete not enabled");
+            if (options?.bulkMode === "perItem") {
+                return this.eachInSavepoint(ids.map((id) => ({ id })), "Mass restore errors", options, ({ id }, opts) => this.restore(id, opts));
+            }
+            const message = "Mass restore errors";
+            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);
+                    const state = this.softDeleteScope(opts);
+                    return this.runSet(tx, message, (sp) => this.updateWhereIn(sp, set, unique, opts, state), unique.map((id) => ({
+                        id,
+                        run: (sp) => this.updateWhereIn(sp, set, [id], opts, state),
+                    })), "write");
+                },
+                after: async (restored) => {
+                    for (const entity of restored)
+                        await this.afterRestore(entity);
+                },
+            });
         });
     }
     async massDelete(ids, options) {
-        options = this.withScopeMemo(options);
-        if (options?.bulkMode === "perItem") {
-            await this.eachInSavepoint(ids.map((id) => ({ id })), "Mass delete errors", options, ({ id }, opts) => this.delete(id, opts), "delete");
+        return this.scopedCall(options, async (options) => {
+            if (options?.bulkMode === "perItem") {
+                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";
+            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((0, drizzle_orm_1.and)(this.writeWhere(keys, opts), this.softDeleteScope(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);
+                },
+            });
             return true;
-        }
-        const message = "Mass delete errors";
-        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((0, drizzle_orm_1.and)(this.writeWhere(keys, opts), this.softDeleteScope(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);
-            },
         });
-        return true;
     }
     async massForceDelete(ids, options) {
         return this.massDelete(ids, {
@@ -2621,6 +2731,10 @@ class SqlBaseCrudService {
             onlyDeleted: false,
         });
     }
+    holdsSql(row) {
+        return ((0, merge_config_1.isPlainObject)(row) &&
+            Object.values(row).some((value) => (0, drizzle_orm_1.is)(value, drizzle_orm_1.SQL)));
+    }
     uniqueIds(ids) {
         const seen = new Set();
         return (ids ?? []).filter((id) => {
@@ -2632,20 +2746,33 @@ class SqlBaseCrudService {
         });
     }
     fingerprint(value) {
-        return JSON.stringify(value, (_key, v) => {
+        return JSON.stringify(value, function (key, json) {
+            const v = this[key];
+            if (v instanceof Date)
+                return `date:${v.getTime()}`;
+            if (ArrayBuffer.isView(v)) {
+                const bytes = new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
+                return `bytes:${bytes.join(",")}`;
+            }
             if (typeof v === "string")
                 return `s:${v}`;
             if (typeof v === "bigint")
                 return `bigint:${v}`;
-            if (typeof v === "number" && !Number.isFinite(v))
+            if (typeof v === "number" && !Number.isFinite(v)) {
                 return `number:${v}`;
+            }
             if (v !== null && typeof v === "object" && !Array.isArray(v)) {
                 const proto = Object.getPrototypeOf(v);
                 if (proto !== Object.prototype && proto !== null) {
-                    return `opaque:${++fingerprintTag}`;
+                    let tag = fingerprintTags.get(v);
+                    if (!tag) {
+                        tag = `opaque:${++fingerprintCount}`;
+                        fingerprintTags.set(v, tag);
+                    }
+                    return tag;
                 }
             }
-            return v;
+            return json;
         });
     }
     async assertAllExist(tx, ids, options, message) {
@@ -2781,44 +2908,50 @@ 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 this.scopedCall(options, async (options) => {
+            this.checkReadOptions({ ...options, select: undefined });
+            const entity = await this.find(id, {
+                ...options,
+                relations: [],
+                counts: undefined,
+                select: [this.config.primaryKey],
+            });
+            return !!entity;
         });
-        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 this.parseCount(result);
+        return this.scopedCall(options, async (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 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);
-        const { conditions, relations: filterRelations } = this.listConditions(filters, db, options);
-        const joins = Array.from(new Set([...filterRelations, ...(spec.relation ? [spec.relation] : [])]));
-        const total = (0, drizzle_orm_1.sql) `count(*)`;
-        let query = db
-            .select({ value: spec.column, count: total })
-            .from(this.config.table);
-        query = this.applyJoins(query, joins, options);
-        if (conditions.length > 0)
-            query = query.where((0, drizzle_orm_1.and)(...conditions));
-        query = query.groupBy(spec.column).orderBy((0, drizzle_orm_1.desc)(total), (0, drizzle_orm_1.asc)(spec.column));
-        const rows = await this.runRead(query);
-        return rows.map((row) => ({
-            value: row.value,
-            count: Number(row.count),
-        }));
+        return this.scopedCall(options, async (options) => {
+            this.checkReadOptions(options);
+            const db = this.dbFor(options?.transaction);
+            const spec = this.resolveGroupColumn(column, options);
+            const { conditions, relations: filterRelations } = this.listConditions(filters, db, options);
+            const joins = Array.from(new Set([
+                ...filterRelations,
+                ...(spec.relation ? [spec.relation] : []),
+            ]));
+            const total = (0, drizzle_orm_1.sql) `count(*)`;
+            let query = db
+                .select({ value: spec.column, count: total })
+                .from(this.config.table);
+            query = this.applyJoins(query, joins, options);
+            if (conditions.length > 0)
+                query = query.where((0, drizzle_orm_1.and)(...conditions));
+            query = query.groupBy(spec.column).orderBy((0, drizzle_orm_1.desc)(total), (0, drizzle_orm_1.asc)(spec.column));
+            const rows = await this.runRead(query);
+            return rows.map((row) => ({
+                value: row.value,
+                count: Number(row.count),
+            }));
+        });
     }
     resolveGroupColumn(key, options) {
         if (typeof key !== "string" || !key) {
@@ -3352,49 +3485,50 @@ 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");
-        }
-        if (!Array.isArray(searchColumns) || searchColumns.length === 0) {
-            throw new common_1.BadRequestException("Full-text search needs at least one column");
-        }
-        const columns = searchColumns.map((name) => {
-            const column = this.columnOf(this.config.table, name);
-            if (!column) {
-                throw new common_1.BadRequestException(`Unknown search column: ${name}`);
+        return this.scopedCall(options, async (options) => {
+            if (this.config.dialect !== "postgresql") {
+                throw new common_1.BadRequestException("Full-text search only supported in PostgreSQL");
             }
-            this.assertAllowed("searchableColumns", name, options);
-            return column;
-        });
-        const { filters, language, queryMode, ...readOptions } = options ?? {};
-        const { vector, query } = this.fullTextParts(columns, searchTerm, {
-            language,
-            queryMode,
+            if (!Array.isArray(searchColumns) || searchColumns.length === 0) {
+                throw new common_1.BadRequestException("Full-text search needs at least one column");
+            }
+            const columns = searchColumns.map((name) => {
+                const column = this.columnOf(this.config.table, name);
+                if (!column) {
+                    throw new common_1.BadRequestException(`Unknown search column: ${name}`);
+                }
+                this.assertAllowed("searchableColumns", name, options);
+                return column;
+            });
+            const { filters, language, queryMode, ...readOptions } = options ?? {};
+            const { vector, query } = this.fullTextParts(columns, searchTerm, {
+                language,
+                queryMode,
+            });
+            const { page, limit, offset } = this.resolvePagination(pagination?.page, pagination?.limit);
+            const plan = this.planList(filters, undefined, "asc", readOptions);
+            const conditions = [(0, drizzle_orm_1.sql) `${vector} @@ ${query}`, ...plan.conditions];
+            const joins = Array.from(new Set([
+                ...plan.joined.map((node) => node.name),
+                ...plan.filterRelations,
+            ]));
+            const pk = this.columnOf(this.config.table, this.config.primaryKey);
+            const orderBy = [(0, drizzle_orm_1.sql) `ts_rank(${vector}, ${query}) DESC`];
+            if (pk)
+                orderBy.push((0, drizzle_orm_1.asc)(pk));
+            let dataQuery = this.startSelect(plan.db, plan.baseSelect, plan.joined, joins.length > 0, plan.selection);
+            dataQuery = this.applyJoins(dataQuery, joins, readOptions)
+                .where((0, drizzle_orm_1.and)(...conditions))
+                .orderBy(...orderBy)
+                .limit(limit)
+                .offset(offset);
+            const countQuery = this.buildCountQuery(plan.db, conditions, plan.filterRelations, readOptions);
+            const [fetched, totalResult] = await this.runRead(Promise.all([dataQuery, countQuery]));
+            const total = this.parseCount(totalResult);
+            const rows = this.normalizeRelations(fetched, plan.joined.map((node) => node.name));
+            await this.hydrate(plan.db, rows, plan.nodes, plan.selection, readOptions);
+            return { data: rows, total, page, limit };
         });
-        const { page, limit, offset } = this.resolvePagination(pagination?.page, pagination?.limit);
-        const plan = this.planList(filters, undefined, "asc", readOptions);
-        const conditions = [(0, drizzle_orm_1.sql) `${vector} @@ ${query}`, ...plan.conditions];
-        const joins = Array.from(new Set([
-            ...plan.joined.map((node) => node.name),
-            ...plan.filterRelations,
-        ]));
-        const pk = this.columnOf(this.config.table, this.config.primaryKey);
-        const orderBy = [(0, drizzle_orm_1.sql) `ts_rank(${vector}, ${query}) DESC`];
-        if (pk)
-            orderBy.push((0, drizzle_orm_1.asc)(pk));
-        let dataQuery = this.startSelect(plan.db, plan.baseSelect, plan.joined, joins.length > 0, plan.selection);
-        dataQuery = this.applyJoins(dataQuery, joins, readOptions)
-            .where((0, drizzle_orm_1.and)(...conditions))
-            .orderBy(...orderBy)
-            .limit(limit)
-            .offset(offset);
-        const countQuery = this.buildCountQuery(plan.db, conditions, plan.filterRelations, readOptions);
-        const [fetched, totalResult] = await this.runRead(Promise.all([dataQuery, countQuery]));
-        const total = this.parseCount(totalResult);
-        const rows = this.normalizeRelations(fetched, plan.joined.map((node) => node.name));
-        await this.hydrate(plan.db, rows, plan.nodes, plan.selection, readOptions);
-        return { data: rows, total, page, limit };
     }
 }
 exports.SqlBaseCrudService = SqlBaseCrudService;