@avytrix/nestjs-drizzle-crud 0.0.0-stage → 3.6.0

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

@@ -0,0 +1,2899 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlBaseCrudService = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const common_1 = require("@nestjs/common");
+const crud_exceptions_1 = require("../../exceptions/crud.exceptions");
+const crud_context_1 = require("../context/crud-context");
+const cursor_1 = require("../utils/cursor");
+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 ROLLBACK = Symbol("rollback");
+const GROUP_KEYS = new Set(["and", "or", "not"]);
+const QUANTIFIERS = new Set(["some", "none", "every"]);
+const COUNT_KEY = "__crudCountKey";
+let aliasSeq = 0;
+function subqueryAlias(table) {
+    aliasSeq = (aliasSeq + 1) % 1_000_000;
+    return typeof drizzle_orm_1.aliasedTable === "function"
+        ? (0, drizzle_orm_1.aliasedTable)(table, `crud_sq${aliasSeq}`)
+        : table;
+}
+class SqlBaseCrudService {
+    config;
+    defaultConfig = {
+        dialect: "postgresql",
+        db: null,
+        table: null,
+        primaryKey: "id",
+        primaryKeyType: "serial",
+        softDelete: { enabled: true, column: "deleted_at" },
+        timestamps: { createdAt: "created_at", updatedAt: "updated_at" },
+        pagination: { defaultLimit: 20, maxLimit: 100 },
+        sql: {
+            caseSensitive: false,
+            useReturning: true,
+            jsonSupport: true,
+            enableFullTextSearch: false,
+        },
+    };
+    buildSelectFields(select) {
+        if (!select || select.length === 0)
+            return undefined;
+        const fields = {};
+        for (const field of select) {
+            const column = this.config.table[field];
+            if (column)
+                fields[field] = column;
+        }
+        return Object.keys(fields).length > 0 ? fields : undefined;
+    }
+    wasAffected(result) {
+        if (result == null)
+            return false;
+        if (Array.isArray(result)) {
+            if (typeof result.count === "number")
+                return result.count > 0;
+            if (result[0] && typeof result[0].affectedRows === "number")
+                return result[0].affectedRows > 0;
+            return result.length > 0;
+        }
+        if (typeof result.rowCount === "number")
+            return result.rowCount > 0;
+        if (typeof result.rowsAffected === "number")
+            return result.rowsAffected > 0;
+        if (typeof result.affectedRows === "number")
+            return result.affectedRows > 0;
+        return false;
+    }
+    buildWhereConditionsFromPartial(where) {
+        const conditions = [];
+        for (const [key, value] of Object.entries(where ?? {})) {
+            if (value === undefined)
+                continue;
+            const column = this.columnOf(this.config.table, key);
+            if (!column) {
+                throw new common_1.BadRequestException(`Unknown filter column: ${key}`);
+            }
+            if (value === null)
+                conditions.push((0, drizzle_orm_1.isNull)(column));
+            else
+                this.pushColumnCondition(conditions, column, value, false);
+        }
+        if (conditions.length === 0) {
+            throw new common_1.BadRequestException("findOne needs at least one condition; every value was undefined");
+        }
+        return conditions;
+    }
+    columnOf(table, name) {
+        if (!table || typeof name !== "string")
+            return undefined;
+        const columns = (0, drizzle_orm_1.getTableColumns)(table) ?? table;
+        return Object.hasOwn(columns, name) ? columns[name] : undefined;
+    }
+    primaryKeyOf(table) {
+        if (table === this.config.table)
+            return this.config.primaryKey;
+        const columns = (0, drizzle_orm_1.getTableColumns)(table) ?? {};
+        for (const [key, column] of Object.entries(columns)) {
+            if (column?.primary)
+                return key;
+        }
+        return "id";
+    }
+    isTextColumn(column) {
+        return /(Text|VarChar|Varchar|Char)$/.test(column?.columnType ?? "");
+    }
+    coerceFilterValue(column, value) {
+        if (column?.dataType !== "date" || value instanceof Date)
+            return value;
+        if (typeof value === "string" || typeof value === "number") {
+            const date = new Date(value);
+            if (!Number.isNaN(date.getTime()))
+                return date;
+        }
+        throw new common_1.BadRequestException(`Invalid date filter value: ${value}`);
+    }
+    static ALLOWLIST_LABELS = {
+        filterableColumns: "Filtering on",
+        sortableColumns: "Sorting by",
+        selectableColumns: "Selecting",
+        searchableColumns: "Searching",
+        loadableRelations: "Loading the relation",
+        writableColumns: "Writing",
+        writableRelations: "Writing the relation",
+    };
+    assertAllowed(list, path, options) {
+        if (options?.skipAllowlists)
+            return;
+        const allowed = this.config[list];
+        if (!allowed)
+            return;
+        if (path === this.config.primaryKey &&
+            (list === "selectableColumns" || list === "sortableColumns")) {
+            return;
+        }
+        if (allowed.includes(path))
+            return;
+        if (list === "loadableRelations" &&
+            allowed.some((entry) => entry.startsWith(`${path}.`))) {
+            return;
+        }
+        throw new common_1.BadRequestException(`${SqlBaseCrudService.ALLOWLIST_LABELS[list]} "${path}" is not allowed`);
+    }
+    checkReadOptions(options) {
+        if (options?.skipAllowlists)
+            return;
+        for (const path of options?.relations ?? []) {
+            if (path)
+                this.assertAllowed("loadableRelations", path, options);
+        }
+        for (const path of options?.select ?? []) {
+            if (path)
+                this.assertAllowed("selectableColumns", path, options);
+        }
+        for (const column of options?.search?.columns ?? []) {
+            this.assertAllowed("searchableColumns", column, options);
+        }
+        for (const name of this.countNames(options?.counts)) {
+            this.assertAllowed("loadableRelations", name, options);
+        }
+    }
+    rowScope(options) {
+        const out = this.scopeConditions(options);
+        const softDeleted = this.softDeleteScope(options);
+        if (softDeleted)
+            out.push(softDeleted);
+        return out;
+    }
+    resolveScope(options) {
+        const scope = this.config.scope;
+        if (!scope || options?.skipScope)
+            return null;
+        const values = typeof scope === "function"
+            ? scope(options?.context ?? crud_context_1.CrudContext.current() ?? {})
+            : scope;
+        if (values === null)
+            return null;
+        if (!(0, merge_config_1.isPlainObject)(values)) {
+            throw new Error(`[nestjs-drizzle-crud] ${this.getEntityName()}: scope must return an object of column values, or null`);
+        }
+        for (const [key, value] of Object.entries(values)) {
+            if (!this.columnOf(this.config.table, key)) {
+                throw new Error(`[nestjs-drizzle-crud] ${this.getEntityName()}: scope names "${key}", which is not a column`);
+            }
+            if (value === undefined) {
+                throw new crud_exceptions_1.MissingScopeException(this.getEntityName(), key);
+            }
+        }
+        return values;
+    }
+    scopeConditions(options, table = this.config.table) {
+        const values = this.resolveScope(options);
+        if (!values)
+            return [];
+        return Object.entries(values).map(([key, value]) => value === null ? (0, drizzle_orm_1.isNull)(table[key]) : (0, drizzle_orm_1.eq)(table[key], value));
+    }
+    relatedRowScope(target, options) {
+        const out = this.relatedScopeConditions(target, options);
+        const softDeleted = this.softDeleteCondition(target);
+        if (softDeleted)
+            out.push(softDeleted);
+        return out;
+    }
+    relatedScopeConditions(target, options) {
+        return Object.entries(this.resolveScope(options) ?? {})
+            .filter(([key]) => this.columnOf(target, key))
+            .map(([key, value]) => value === null ? (0, drizzle_orm_1.isNull)(target[key]) : (0, drizzle_orm_1.eq)(target[key], value));
+    }
+    applyScopeToRow(row, options) {
+        const values = this.resolveScope(options);
+        if (values)
+            Object.assign(row, values);
+    }
+    softDeleteScope(options) {
+        const softDelete = this.config.softDelete;
+        if (options?.onlyDeleted) {
+            if (!softDelete?.enabled) {
+                throw new common_1.BadRequestException("onlyDeleted needs soft delete, which is off for this entity");
+            }
+            return (0, drizzle_orm_1.isNotNull)(this.config.table[softDelete.column]);
+        }
+        if (!softDelete?.enabled || options?.withDeleted)
+            return undefined;
+        return (0, drizzle_orm_1.isNull)(this.config.table[softDelete.column]);
+    }
+    managedColumns(operation) {
+        const out = [];
+        if (this.config.softDelete?.enabled)
+            out.push(this.config.softDelete.column);
+        if (this.config.versionColumn)
+            out.push(this.config.versionColumn);
+        if (operation === "update") {
+            out.push(this.config.primaryKey);
+            if (this.config.timestamps?.createdAt) {
+                out.push(this.config.timestamps.createdAt);
+            }
+        }
+        return out;
+    }
+    filterWritable(entity, operation, options) {
+        const out = { ...entity };
+        const allowed = this.config.writableColumns;
+        if (allowed && !options?.skipAllowlists) {
+            for (const [key, value] of Object.entries(out)) {
+                if (value === undefined || !this.columnOf(this.config.table, key)) {
+                    continue;
+                }
+                if (!allowed.includes(key)) {
+                    throw new crud_exceptions_1.ValidationFailedException(`the column "${key}" is not writable`);
+                }
+            }
+            return out;
+        }
+        if (allowed)
+            return out;
+        for (const key of this.managedColumns(operation))
+            delete out[key];
+        return out;
+    }
+    keyOf(value) {
+        const column = this.columnOf(this.config.table, this.config.primaryKey);
+        const key = String(value);
+        return column?.columnType === "PgUUID" ? key.toLowerCase() : key;
+    }
+    constructor(config) {
+        this.config = config;
+        this.config = (0, merge_config_1.mergeCrudConfig)(this.defaultConfig, config);
+        this.validateConfiguration();
+    }
+    validateConfiguration() {
+        if (!this.config.db)
+            throw new Error("Database instance is required");
+        if (!this.config.table)
+            throw new Error("Table configuration is required");
+        if (this.config.dialect === "mysql" && this.config.sql?.useReturning) {
+            console.warn("MySQL does not support RETURNING clause, disabling useReturning");
+            this.config.sql.useReturning = false;
+        }
+        this.validateColumns();
+        this.validateRelations(this.config.relations);
+    }
+    validateColumns() {
+        const table = this.config.table;
+        const check = (setting, name) => {
+            if (!name || this.columnOf(table, name))
+                return;
+            const declared = Object.entries((0, drizzle_orm_1.getTableColumns)(table) ?? {}).find(([, column]) => column?.name === name)?.[0];
+            const hint = declared
+                ? `The column "${name}" is declared under the key "${declared}"; set ${setting} to "${declared}".`
+                : `Set ${setting} to the key of an existing column, or turn it off for this entity.`;
+            throw new Error(`[nestjs-drizzle-crud] ${this.getEntityName()}: ${setting} is "${name}", but the table has no column under that key. ${hint}`);
+        };
+        if (this.config.softDelete?.enabled) {
+            check("softDelete.column", this.config.softDelete.column);
+        }
+        if (this.config.timestamps) {
+            check("timestamps.createdAt", this.config.timestamps.createdAt);
+            check("timestamps.updatedAt", this.config.timestamps.updatedAt);
+        }
+        if (this.config.versionColumn) {
+            check("versionColumn", this.config.versionColumn);
+        }
+        const scope = this.config.scope;
+        if (scope && typeof scope !== "function") {
+            for (const key of Object.keys(scope))
+                check(`scope.${key}`, key);
+        }
+    }
+    validateRelations(relations, path = "") {
+        for (const [name, relation] of Object.entries(relations || {})) {
+            const label = path ? `${path}.${name}` : name;
+            if (!relation?.table) {
+                throw new Error(`Relation "${label}" is missing its table`);
+            }
+            switch (this.relationType(relation)) {
+                case "hasMany":
+                    if (!relation.foreignKey) {
+                        throw new Error(`Relation "${label}" is hasMany and requires a foreignKey (the column on the related table pointing back here)`);
+                    }
+                    break;
+                case "manyToMany":
+                    if (!relation.through ||
+                        !relation.throughLocalKey ||
+                        !relation.throughForeignKey) {
+                        throw new Error(`Relation "${label}" is manyToMany and requires through, throughLocalKey and throughForeignKey (the join table and its two foreign-key columns)`);
+                    }
+                    break;
+                default:
+                    if (!relation.localKey) {
+                        throw new Error(`Relation "${label}" is belongsTo and requires a localKey (the foreign-key column on this table)`);
+                    }
+            }
+            this.validateRelations(relation.relations, label);
+        }
+    }
+    async validateCreate(_data) { }
+    async validateUpdate(_id, _data) { }
+    mapCreateDtoToEntity(data) {
+        return { ...data };
+    }
+    mapUpdateDtoToEntity(data) {
+        return { ...data };
+    }
+    async beforeCreate(data) {
+        return data;
+    }
+    async afterCreate(_entity) { }
+    async beforeUpdate(_id, data) {
+        return data;
+    }
+    async afterUpdate(_entity) { }
+    async beforeDelete(_id) { }
+    async afterDelete(_id) { }
+    async beforeSoftDelete(_id) { }
+    async afterSoftDelete(_id) { }
+    async beforeRestore(_id) { }
+    async afterRestore(_entity) { }
+    relationType(relation) {
+        if (relation.type === "hasMany" || relation.type === "manyToMany")
+            return relation.type;
+        return "belongsTo";
+    }
+    isCollection(relation) {
+        return this.relationType(relation) !== "belongsTo";
+    }
+    eagerRelations(relations) {
+        const configured = this.config.relations || {};
+        return (relations || []).filter((name) => !!configured[name]);
+    }
+    relationTree(paths, configured = this.config.relations || {}) {
+        const roots = [];
+        for (const path of paths || []) {
+            let level = configured;
+            let siblings = roots;
+            for (const name of (path || "").split(".").filter(Boolean)) {
+                const config = level?.[name];
+                if (!config)
+                    break;
+                let node = siblings.find((candidate) => candidate.name === name);
+                if (!node) {
+                    node = { name, config, children: [] };
+                    siblings.push(node);
+                }
+                level = config.relations || {};
+                siblings = node.children;
+            }
+        }
+        return roots;
+    }
+    parseSelect(select) {
+        const root = { base: [], relations: {} };
+        for (const entry of select || []) {
+            const segments = (entry || "").split(".").filter(Boolean);
+            if (segments.length === 0)
+                continue;
+            let node = root;
+            for (const name of segments.slice(0, -1)) {
+                if (!node.relations[name])
+                    node.relations[name] = { base: [], relations: {} };
+                node = node.relations[name];
+            }
+            node.base.push(segments[segments.length - 1]);
+        }
+        return root;
+    }
+    selectFor(select, name) {
+        return select.relations[name] ?? { base: [], relations: {} };
+    }
+    keysForChildren(nodes, hostTable = this.config.table) {
+        return nodes
+            .map((node) => this.relationType(node.config) === "belongsTo"
+            ? node.config.localKey
+            : this.parentKeyOf(node.config, hostTable))
+            .filter((key) => !!key);
+    }
+    parentKeyOf(relation, hostTable = this.config.table) {
+        return relation.parentKey ?? this.primaryKeyOf(hostTable);
+    }
+    withRequiredKeys(base, nodes) {
+        if (base.length === 0)
+            return base;
+        const keys = this.keysForChildren(nodes.filter((node) => !node.joined));
+        return keys.length > 0 ? Array.from(new Set([...base, ...keys])) : base;
+    }
+    buildSelection(base, joined, select = { base: [], relations: {} }) {
+        const allColumns = (0, drizzle_orm_1.getTableColumns)(this.config.table);
+        let fields;
+        if (base.length > 0) {
+            fields = {};
+            for (const name of base) {
+                if (allColumns[name])
+                    fields[name] = allColumns[name];
+            }
+        }
+        else {
+            fields = { ...allColumns };
+        }
+        for (const node of joined) {
+            const relColumns = (0, drizzle_orm_1.getTableColumns)(node.config.table);
+            const wanted = this.selectFor(select, node.name).base;
+            if (wanted.length > 0) {
+                const picked = {};
+                for (const name of [
+                    ...wanted,
+                    ...this.keysForChildren(node.children, node.config.table),
+                ]) {
+                    if (relColumns[name])
+                        picked[name] = relColumns[name];
+                }
+                fields[node.name] =
+                    Object.keys(picked).length > 0 ? picked : relColumns;
+            }
+            else {
+                fields[node.name] = relColumns;
+            }
+        }
+        return fields;
+    }
+    startSelect(db, base, joined, hasJoins = false, select = { base: [], relations: {} }) {
+        if (joined.length > 0 || hasJoins) {
+            return db
+                .select(this.buildSelection(base, joined, select))
+                .from(this.config.table);
+        }
+        const fields = this.buildSelectFields(base);
+        return fields
+            ? db.select(fields).from(this.config.table)
+            : db.select().from(this.config.table);
+    }
+    planJoins(nodes) {
+        const joined = [];
+        for (const node of nodes) {
+            if (this.isCollection(node.config) || !node.config.localKey)
+                continue;
+            node.joined = true;
+            joined.push(node);
+        }
+        return joined;
+    }
+    collectionOrderBy(relation) {
+        const out = [];
+        for (const spec of relation.orderBy ?? []) {
+            const column = relation.table[spec.column];
+            if (!column) {
+                console.warn(`[nestjs-drizzle-crud] relation orderBy references unknown column "${spec.column}"; skipping.`);
+                continue;
+            }
+            out.push(spec.order === "desc" ? (0, drizzle_orm_1.desc)(column) : (0, drizzle_orm_1.asc)(column));
+        }
+        return out;
+    }
+    softDeleteCondition(table) {
+        const softDelete = this.config.softDelete;
+        if (!softDelete?.enabled)
+            return undefined;
+        const column = table[softDelete.column];
+        return column ? (0, drizzle_orm_1.isNull)(column) : undefined;
+    }
+    relationProjection(table, wanted, requiredKeys) {
+        if (wanted.length === 0)
+            return undefined;
+        const fields = {};
+        for (const name of [...wanted, ...requiredKeys]) {
+            const column = table[name];
+            if (column)
+                fields[name] = column;
+        }
+        return Object.keys(fields).length > 0 ? fields : undefined;
+    }
+    async loadRelations(db, hosts, nodes, select = { base: [], relations: {} }, hostTable = this.config.table, options) {
+        if (!nodes.length || !Array.isArray(hosts))
+            return;
+        const rows = hosts.filter((row) => row && typeof row === "object");
+        if (rows.length === 0)
+            return;
+        await Promise.all(nodes.map(async (node) => {
+            const childSelect = this.selectFor(select, node.name);
+            if (!node.joined) {
+                switch (this.relationType(node.config)) {
+                    case "hasMany":
+                        await this.loadHasMany(db, rows, node, childSelect, hostTable, options);
+                        break;
+                    case "manyToMany":
+                        await this.loadManyToMany(db, rows, node, childSelect, hostTable, options);
+                        break;
+                    default:
+                        await this.loadBelongsTo(db, rows, node, childSelect, options);
+                }
+            }
+            if (node.children.length === 0)
+                return;
+            const nextHosts = this.isCollection(node.config)
+                ? rows.flatMap((row) => row[node.name] ?? [])
+                : rows.map((row) => row[node.name]);
+            await this.loadRelations(db, nextHosts, node.children, childSelect, node.config.table, options);
+        }));
+    }
+    async loadBelongsTo(db, hosts, node, select, options) {
+        const { localKey, references } = node.config;
+        if (!localKey)
+            return;
+        const target = node.config.table;
+        const referencedName = references ?? "id";
+        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;
+            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())
+            .from(target)
+            .where((0, drizzle_orm_1.and)(...conditions));
+        const byKey = new Map();
+        for (const row of related ?? [])
+            byKey.set(row?.[referencedName], row);
+        for (const host of hosts) {
+            host[node.name] = byKey.get(host[localKey]) ?? null;
+        }
+    }
+    async loadHasMany(db, hosts, node, select, hostTable = this.config.table, options) {
+        const { foreignKey } = node.config;
+        if (!foreignKey)
+            return;
+        const target = node.config.table;
+        const foreign = target[foreignKey];
+        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] = [];
+            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;
+        this.groupCollection(hosts, node.name, parentKey, children, foreignKey);
+    }
+    async loadManyToMany(db, hosts, node, select, hostTable = this.config.table, options) {
+        const { through, throughLocalKey, throughForeignKey, references } = node.config;
+        if (!through || !throughLocalKey || !throughForeignKey)
+            return;
+        const target = node.config.table;
+        const referencedName = references ?? "id";
+        const referenced = target[referencedName];
+        const joinLocal = through[throughLocalKey];
+        const joinForeign = through[throughForeignKey];
+        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] = [];
+            return;
+        }
+        const columns = (0, drizzle_orm_1.getTableColumns)(target);
+        const wanted = select.base.length > 0
+            ? [...select.base, ...this.keysForChildren(node.children, target)]
+            : Object.keys(columns);
+        const fields = { [JOIN_KEY]: joinLocal };
+        for (const name of wanted) {
+            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;
+        this.groupCollection(hosts, node.name, parentKey, rows, JOIN_KEY, true);
+    }
+    groupCollection(hosts, name, parentKey, rows, groupBy, stripGroupKey = false) {
+        const grouped = new Map();
+        for (const row of rows ?? []) {
+            if (!row)
+                continue;
+            const key = row[groupBy];
+            if (stripGroupKey)
+                delete row[groupBy];
+            const bucket = grouped.get(key);
+            if (bucket)
+                bucket.push(row);
+            else
+                grouped.set(key, [row]);
+        }
+        for (const host of hosts) {
+            host[name] = grouped.get(host[parentKey]) ?? [];
+        }
+    }
+    applyJoins(query, relationNames, options) {
+        const configured = this.config.relations || {};
+        let q = query;
+        for (const name of relationNames) {
+            const rel = configured[name];
+            if (!rel?.localKey || this.isCollection(rel))
+                continue;
+            const on = (0, drizzle_orm_1.eq)(this.config.table[rel.localKey], rel.table[rel.references ?? "id"]);
+            q = q.leftJoin(rel.table, (0, drizzle_orm_1.and)(on, ...this.relatedRowScope(rel.table, options)));
+        }
+        return q;
+    }
+    normalizeRelations(rows, eager) {
+        if (!eager.length || !Array.isArray(rows))
+            return rows;
+        return rows.map((row) => {
+            if (!row || typeof row !== "object")
+                return row;
+            const out = { ...row };
+            for (const name of eager) {
+                const related = out[name];
+                if (related &&
+                    typeof related === "object" &&
+                    Object.values(related).every((v) => v === null)) {
+                    out[name] = null;
+                }
+            }
+            return out;
+        });
+    }
+    buildOrderBy(sortBy, sortOrder = "asc") {
+        return this.resolveSort(sortBy, sortOrder).map((spec) => this.orderOf(spec));
+    }
+    orderOf(spec) {
+        return spec.order === "desc" ? (0, drizzle_orm_1.desc)(spec.column) : (0, drizzle_orm_1.asc)(spec.column);
+    }
+    resolveSort(sortBy, sortOrder = "asc", options) {
+        if (sortOrder !== "asc" && sortOrder !== "desc") {
+            throw new common_1.BadRequestException(`Invalid sortOrder: ${sortOrder} (expected 'asc' or 'desc')`);
+        }
+        const specs = [];
+        const add = (spec) => {
+            if (!specs.some((existing) => existing.column === spec.column)) {
+                specs.push(spec);
+            }
+        };
+        const entries = this.sortEntries(sortBy, sortOrder);
+        if (entries.length > 0) {
+            for (const entry of entries) {
+                this.assertAllowed("sortableColumns", entry.column, options);
+                add(this.resolveSortColumn(entry.column, entry.order ?? "asc"));
+            }
+        }
+        else {
+            for (const entry of this.config.defaultSort ?? []) {
+                try {
+                    add(this.resolveSortColumn(entry.column, entry.order ?? "asc"));
+                }
+                catch {
+                    console.warn(`[nestjs-drizzle-crud] defaultSort references unknown column "${entry.column}"; skipping.`);
+                }
+            }
+        }
+        const pk = this.columnOf(this.config.table, this.config.primaryKey);
+        if (pk)
+            add({ key: this.config.primaryKey, column: pk, order: "asc" });
+        return specs;
+    }
+    sortEntries(sortBy, sortOrder) {
+        const fromString = (entry) => {
+            const name = entry.trim();
+            if (name.startsWith("-"))
+                return { column: name.slice(1), order: "desc" };
+            if (name.startsWith("+"))
+                return { column: name.slice(1), order: "asc" };
+            return { column: name, order: "asc" };
+        };
+        if (typeof sortBy === "string") {
+            if (!sortBy.trim())
+                return [];
+            if (!sortBy.includes(",")) {
+                const entry = fromString(sortBy);
+                return [
+                    sortBy.trim().startsWith("-") || sortBy.trim().startsWith("+")
+                        ? entry
+                        : { column: entry.column, order: sortOrder },
+                ];
+            }
+            return sortBy
+                .split(",")
+                .filter((part) => part.trim())
+                .map(fromString);
+        }
+        if (!Array.isArray(sortBy))
+            return [];
+        return sortBy.map((entry) => {
+            if (typeof entry === "string")
+                return fromString(entry);
+            if (!(0, merge_config_1.isPlainObject)(entry) ||
+                typeof entry.column !== "string" ||
+                (entry.order !== undefined &&
+                    entry.order !== "asc" &&
+                    entry.order !== "desc")) {
+                throw new common_1.BadRequestException("Each sortBy entry is a column name or { column, order }");
+            }
+            return entry;
+        });
+    }
+    resolveSortColumn(key, order) {
+        const dot = key.indexOf(".");
+        if (dot < 0) {
+            const column = this.columnOf(this.config.table, key);
+            if (!column)
+                throw new common_1.BadRequestException(`Unknown sort column: ${key}`);
+            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 column = relation
+            ? this.columnOf(relation.table, key.slice(dot + 1))
+            : undefined;
+        if (!relation || !column) {
+            throw new common_1.BadRequestException(`Unknown sort column: ${key}`);
+        }
+        if (this.isCollection(relation) || !relation.localKey) {
+            throw new common_1.BadRequestException(`Cannot sort by "${key}": only a belongs-to relation column can be sorted on`);
+        }
+        return { key, column, order, relation: name };
+    }
+    resolvePagination(page, limit) {
+        const maxLimit = this.config.pagination?.maxLimit ?? 100;
+        const defaultLimit = this.config.pagination?.defaultLimit ?? 20;
+        const rawPage = page == null || Number.isNaN(Number(page)) ? 1 : Math.floor(Number(page));
+        const rawLimit = limit == null || Number.isNaN(Number(limit))
+            ? defaultLimit
+            : Math.floor(Number(limit));
+        const safePage = Math.max(1, rawPage);
+        const safeLimit = Math.min(Math.max(1, rawLimit), maxLimit);
+        return {
+            page: safePage,
+            limit: safeLimit,
+            offset: (safePage - 1) * safeLimit,
+        };
+    }
+    isUniqueViolation(error) {
+        const code = error?.code ?? error?.cause?.code;
+        const errno = error?.errno ?? error?.cause?.errno;
+        return code === "23505" || code === "ER_DUP_ENTRY" || errno === 1062;
+    }
+    toDuplicateException(error) {
+        const detail = error?.detail ?? error?.cause?.detail ?? "";
+        const message = error?.cause?.message ?? error?.message ?? "";
+        const m = detail.match(/Key \((?<field>.+?)\)=\((?<value>.+?)\)/) ??
+            message.match(/Duplicate entry '(?<value>.*)' for key '(?:[^']*\.)?(?<field>[^']+)'/);
+        return new crud_exceptions_1.DuplicateEntityException(this.getEntityName(), m?.groups?.field ?? "unique field", m?.groups?.value ?? "");
+    }
+    static DATA_ERRORS = {
+        "23502": "a required value is missing",
+        "22001": "a value is too long for its column",
+        "23514": "a value violates a column check constraint",
+        "22003": "a numeric value is out of range",
+        "22P02": "a value does not match its column type",
+        "22007": "a date or time value has an invalid format",
+        "22008": "a date or time value is out of range",
+        "21000": "the same key appears more than once in one upsert",
+    };
+    isDataException(error) {
+        const code = error?.code ?? error?.cause?.code;
+        return Object.hasOwn(SqlBaseCrudService.DATA_ERRORS, code ?? "");
+    }
+    toDataException(error) {
+        const code = error?.code ?? error?.cause?.code;
+        const message = SqlBaseCrudService.DATA_ERRORS[code] ?? "invalid value";
+        const cause = error?.cause ?? error;
+        const column = error?.column ??
+            cause?.column ??
+            error?.column_name ??
+            cause?.column_name;
+        return new crud_exceptions_1.ValidationFailedException(column ? `${message}: ${column}` : message);
+    }
+    toClientError(error, operation = "write") {
+        if (this.isUniqueViolation(error))
+            return this.toDuplicateException(error);
+        if (this.isDataException(error))
+            return this.toDataException(error);
+        if (this.isForeignKeyViolation(error)) {
+            return operation === "delete"
+                ? new crud_exceptions_1.EntityInUseException(this.getEntityName())
+                : this.toForeignKeyException(error);
+        }
+        return error;
+    }
+    async runRead(query) {
+        try {
+            return await query;
+        }
+        catch (error) {
+            throw this.toClientError(error, "read");
+        }
+    }
+    isForeignKeyViolation(error) {
+        const code = error?.code ?? error?.cause?.code;
+        const errno = error?.errno ?? error?.cause?.errno;
+        return code === "23503" || errno === 1451 || errno === 1452;
+    }
+    toForeignKeyException(error) {
+        const detail = error?.detail ?? error?.cause?.detail ?? "";
+        const m = detail.match(/Key \((?<field>.+?)\)=/);
+        return new crud_exceptions_1.ForeignKeyViolationException(this.getEntityName(), m?.groups?.field ?? "reference");
+    }
+    applyLock(query, options) {
+        if (this.config.dialect !== "postgresql")
+            return query;
+        const of = { of: this.config.table };
+        if (options?.forNoKeyUpdate)
+            return query.for("no key update", of);
+        if (options?.lock && options.lock !== "none")
+            return query.for(options.lock, of);
+        return query;
+    }
+    buildSearchCondition(search) {
+        if (!search?.term || !search.columns?.length)
+            return undefined;
+        const term = String(search.term).trim();
+        if (!term)
+            return undefined;
+        const columns = search.columns
+            .map((columnName) => this.config.table[columnName])
+            .filter(Boolean);
+        if (columns.length === 0)
+            return undefined;
+        if (search.mode === "fullText") {
+            if (this.config.dialect !== "postgresql") {
+                throw new common_1.BadRequestException("Full-text search only supported in PostgreSQL");
+            }
+            const tsVector = drizzle_orm_1.sql.join(columns.map((column) => (0, drizzle_orm_1.sql) `to_tsvector('english', ${column})`), (0, drizzle_orm_1.sql) ` || `);
+            const tsQuery = (0, drizzle_orm_1.sql) `plainto_tsquery('english', ${term})`;
+            return (0, drizzle_orm_1.sql) `${tsVector} @@ ${tsQuery}`;
+        }
+        const pattern = `%${term.replace(/[\\%_]/g, "\\$&")}%`;
+        const conditions = columns.map((column) => this.caseInsensitiveLike(column, pattern));
+        return conditions.length === 1 ? conditions[0] : (0, drizzle_orm_1.or)(...conditions);
+    }
+    caseInsensitiveLike(column, pattern) {
+        return this.config.dialect === "mysql"
+            ? (0, drizzle_orm_1.like)(column, pattern)
+            : (0, drizzle_orm_1.ilike)(column, pattern);
+    }
+    parseQuery(query, options = {}) {
+        const config = this.config;
+        return (0, query_parser_1.parseCrudQuery)(query, config.table, {
+            relations: config.relations,
+            primaryKey: config.primaryKey,
+            filterableColumns: config.filterableColumns,
+            sortableColumns: config.sortableColumns,
+            selectableColumns: config.selectableColumns,
+            searchableColumns: config.searchableColumns,
+            loadableRelations: config.loadableRelations,
+            ...options,
+        });
+    }
+    idKind() {
+        const column = this.columnOf(this.config.table, this.config.primaryKey);
+        if (column?.dataType === "bigint")
+            return "bigint";
+        if (column?.dataType === "number") {
+            return /Numeric|Decimal|Real|Double|Float/.test(column.columnType ?? "")
+                ? "string"
+                : "int";
+        }
+        if (/UUID/i.test(column?.columnType ?? ""))
+            return "uuid";
+        return "string";
+    }
+    async parseId(raw) {
+        const value = String(raw);
+        const metadata = { type: "param", data: "id" };
+        switch (this.idKind()) {
+            case "int":
+                return new common_1.ParseIntPipe().transform(value, metadata);
+            case "uuid":
+                return new common_1.ParseUUIDPipe().transform(value, metadata);
+            case "bigint":
+                if (!/^-?\d+$/.test(value)) {
+                    throw new common_1.BadRequestException("Validation failed (numeric string is expected)");
+                }
+                return BigInt(value);
+            default:
+                return value;
+        }
+    }
+    async findForGuard(id, options) {
+        const version = this.config.versionColumn;
+        const row = await this.find(id, {
+            ...options,
+            relations: [],
+            counts: undefined,
+            select: version
+                ? [this.config.primaryKey, version]
+                : [this.config.primaryKey],
+            skipAllowlists: true,
+        });
+        if (row && version) {
+            this.assertVersion(id, row[version], options?.expectedVersion);
+        }
+        return row;
+    }
+    assertVersion(id, actual, expected) {
+        if (expected === undefined || expected === null)
+            return;
+        if (Number(actual) !== Number(expected)) {
+            throw new crud_exceptions_1.StaleVersionException(this.getEntityName(), id);
+        }
+    }
+    writeWhere(ids, options, table = this.config.table) {
+        const pk = table[this.config.primaryKey];
+        const conditions = [
+            ids.length === 1 ? (0, drizzle_orm_1.eq)(pk, ids[0]) : (0, drizzle_orm_1.inArray)(pk, ids),
+            ...this.scopeConditions(options, table),
+        ];
+        const version = this.config.versionColumn;
+        if (version) {
+            if (ids.length === 1 &&
+                options?.expectedVersion != null &&
+                !options.expectedVersions) {
+                conditions.push((0, drizzle_orm_1.eq)(table[version], options.expectedVersion));
+            }
+            else if (options?.expectedVersions) {
+                const checks = ids.flatMap((id) => {
+                    const expected = options.expectedVersions?.[this.keyOf(id)];
+                    return expected == null
+                        ? [(0, drizzle_orm_1.eq)(pk, id)]
+                        : [(0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(pk, id), (0, drizzle_orm_1.eq)(table[version], expected))];
+                });
+                conditions.push(checks.length === 1 ? checks[0] : (0, drizzle_orm_1.or)(...checks));
+            }
+        }
+        return (0, drizzle_orm_1.and)(...conditions);
+    }
+    withVersionBump(set) {
+        const version = this.config.versionColumn;
+        if (!version)
+            return set;
+        return {
+            ...set,
+            [version]: (0, drizzle_orm_1.sql) `${this.config.table[version]} + 1`,
+        };
+    }
+    async find(id, options) {
+        this.checkReadOptions(options);
+        return this.findFirst([(0, drizzle_orm_1.eq)(this.config.table[this.config.primaryKey], id)], options);
+    }
+    async findOne(where, options) {
+        this.checkReadOptions(options);
+        return this.findFirst(this.buildWhereConditionsFromPartial(where), options);
+    }
+    async findFirst(conditions, options) {
+        const { transaction, relations = [], select = [] } = options || {};
+        const db = transaction || this.config.db;
+        const nodes = this.relationTree(relations);
+        const joined = this.planJoins(nodes);
+        const selection = this.parseSelect(select);
+        const baseSelect = this.withCountKeys(this.withRequiredKeys(selection.base, nodes), options?.counts);
+        conditions.push(...this.rowScope(options));
+        let query = this.startSelect(db, baseSelect, joined, false, selection);
+        query = this.applyJoins(query, joined.map((node) => node.name), options)
+            .where((0, drizzle_orm_1.and)(...conditions))
+            .limit(1);
+        query = this.applyLock(query, options);
+        const result = await this.runRead(query);
+        const rows = this.normalizeRelations(result, joined.map((node) => node.name));
+        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);
+        const { transaction, relations = [], select = [] } = options || {};
+        const db = transaction || this.config.db;
+        const nodes = this.relationTree(relations);
+        const joined = this.planJoins(nodes);
+        const selection = this.parseSelect(select);
+        const baseSelect = this.withCountKeys(this.withRequiredKeys(selection.base, nodes), options?.counts);
+        const { conditions, relations: filterRelations } = this.listConditions(filters, db, options);
+        const sort = this.resolveSort(sortBy, sortOrder, options);
+        const joinRelations = Array.from(new Set([
+            ...joined.map((node) => node.name),
+            ...filterRelations,
+            ...sort.flatMap((spec) => (spec.relation ? [spec.relation] : [])),
+        ]));
+        return {
+            db,
+            nodes,
+            joined,
+            selection,
+            baseSelect,
+            conditions,
+            filterRelations,
+            sort,
+            joinRelations,
+        };
+    }
+    listConditions(filters, db, options) {
+        const built = this.buildFilterConditions(filters, db, options);
+        const searchCondition = this.buildSearchCondition(options?.search);
+        if (searchCondition)
+            built.conditions.push(searchCondition);
+        built.conditions.push(...this.rowScope(options));
+        return built;
+    }
+    buildCountQuery(db, conditions, filterRelations, options) {
+        let query = db
+            .select({ count: (0, drizzle_orm_1.sql) `count(*)` })
+            .from(this.config.table);
+        query = this.applyJoins(query, filterRelations, options);
+        if (conditions.length > 0)
+            query = query.where((0, drizzle_orm_1.and)(...conditions));
+        return query;
+    }
+    async findAll(filters, pagination, 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 Promise.all([
+            this.loadRelations(plan.db, rows, plan.nodes, plan.selection, undefined, options),
+            this.loadCounts(plan.db, rows, options?.counts, options),
+        ]);
+        if (!withCount) {
+            return {
+                data: rows,
+                total: null,
+                page,
+                limit: safeLimit,
+                hasMore: fetched.length > safeLimit,
+            };
+        }
+        return {
+            data: rows,
+            total: parseInt(totalResult[0]?.count?.toString() || "0", 10),
+            page,
+            limit: safeLimit,
+        };
+    }
+    async findByCursor(filters, pagination, 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);
+        plan.sort.forEach((spec, i) => {
+            fields[`${CURSOR_KEY}${i}`] = this.cursorField(spec.column);
+        });
+        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)(plan.sort.map((_, i) => last[`${CURSOR_KEY}${i}`]), signature)
+            : null;
+        for (const row of page) {
+            plan.sort.forEach((_, i) => {
+                delete row[`${CURSOR_KEY}${i}`];
+            });
+        }
+        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),
+        ]);
+        const out = { data: rows, limit, nextCursor };
+        if (count) {
+            out.total = parseInt(totalResult?.[0]?.count?.toString() || "0", 10);
+        }
+        return out;
+    }
+    cursorField(column) {
+        if (column?.dataType !== "date")
+            return column;
+        return this.config.dialect === "mysql"
+            ? (0, drizzle_orm_1.sql) `cast(${column} as char)`
+            : (0, drizzle_orm_1.sql) `cast(${column} as text)`;
+    }
+    compareCursor(column, op, value) {
+        if (column?.dataType === "date") {
+            return (0, drizzle_orm_1.sql) `${column} ${drizzle_orm_1.sql.raw(op)} ${value}`;
+        }
+        if (op === ">")
+            return (0, drizzle_orm_1.gt)(column, value);
+        if (op === "<")
+            return (0, drizzle_orm_1.lt)(column, value);
+        return (0, drizzle_orm_1.eq)(column, value);
+    }
+    keysetCondition(specs, values) {
+        const branches = [];
+        specs.forEach((spec, i) => {
+            const after = this.afterCursor(spec, values[i]);
+            if (!after)
+                return;
+            const ties = specs
+                .slice(0, i)
+                .map((previous, j) => values[j] === null
+                ? (0, drizzle_orm_1.isNull)(previous.column)
+                : 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`;
+    }
+    afterCursor(spec, value) {
+        const postgres = this.config.dialect !== "mysql";
+        const nullsFirst = postgres ? spec.order === "desc" : spec.order === "asc";
+        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));
+    }
+    async emitEvent(phase, operation, bulk, payload, options) {
+        const bus = this.config.events;
+        if (!bus || options?.skipEvents)
+            return;
+        await bus.emit({
+            entity: this.getEntityName(),
+            operation,
+            phase,
+            bulk,
+            ids: payload.ids ?? [],
+            input: payload.input,
+            rows: payload.rows ?? [],
+            transaction: payload.transaction,
+            context: options?.context ?? crud_context_1.CrudContext.current(),
+        });
+    }
+    idsOf(rows) {
+        return rows.map((row) => row?.[this.config.primaryKey]);
+    }
+    async loadWriteRelations(db, rows, options) {
+        const nodes = this.relationTree(options?.relations ?? []);
+        if (nodes.length === 0 && this.countNames(options?.counts).length === 0) {
+            return;
+        }
+        const hosts = rows.filter(Boolean);
+        await Promise.all([
+            this.loadRelations(db, hosts, nodes, undefined, undefined, options),
+            this.loadCounts(db, hosts, options?.counts, options),
+        ]);
+    }
+    expectedVersionOf(data, options) {
+        const column = this.config.versionColumn;
+        if (!column)
+            return undefined;
+        const raw = options?.expectedVersion ??
+            ((0, merge_config_1.isPlainObject)(data) ? data[column] : undefined);
+        if (raw === undefined || raw === null || raw === "")
+            return undefined;
+        const version = Number(raw);
+        if (!Number.isInteger(version)) {
+            throw new crud_exceptions_1.ValidationFailedException(`"${column}" must be an integer version`);
+        }
+        return version;
+    }
+    async prepareCreate(data, options) {
+        const hooks = options?.hooks ?? {};
+        await this.validateCreate(data);
+        const processedData = hooks.skipBefore
+            ? data
+            : await this.beforeCreate(data);
+        const mapped = this.mapCreateDtoToEntity(processedData);
+        const version = this.config.versionColumn;
+        if (version)
+            delete mapped[version];
+        const entityData = this.filterWritable(mapped, "create", options);
+        const now = new Date();
+        if (this.config.timestamps?.createdAt)
+            entityData[this.config.timestamps.createdAt] = now;
+        if (this.config.timestamps?.updatedAt)
+            entityData[this.config.timestamps.updatedAt] = now;
+        if (version)
+            entityData[version] = 1;
+        this.applyScopeToRow(entityData, options);
+        return entityData;
+    }
+    async insertOne(db, entityData, options) {
+        const insertQuery = db.insert(this.config.table).values(entityData);
+        if (this.config.sql?.useReturning) {
+            const result = await insertQuery.returning();
+            return result[0];
+        }
+        const result = await insertQuery;
+        const lastInsertId = entityData[this.config.primaryKey] ?? result?.[0]?.insertId;
+        const createdEntity = await this.find(lastInsertId, {
+            ...options,
+            relations: [],
+            counts: undefined,
+            transaction: db,
+        });
+        if (!createdEntity)
+            throw new Error("Failed to create entity");
+        return createdEntity;
+    }
+    async create(data, options) {
+        const { transaction, hooks = {} } = options || {};
+        this.checkReadOptions(options);
+        const entityData = await this.prepareCreate(data, options);
+        const nested = this.takeNested(entityData, options);
+        const db = transaction || this.config.db;
+        await this.emitEvent("before", "create", false, { input: data, transaction }, options);
+        try {
+            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;
+        if (!allowed)
+            return [];
+        const relations = this.config.relations || {};
+        const out = [];
+        for (const [key, value] of Object.entries(entity)) {
+            if (value === undefined ||
+                this.columnOf(this.config.table, key) ||
+                !Object.hasOwn(relations, key)) {
+                continue;
+            }
+            if (!allowed.includes(key) && !options?.skipAllowlists) {
+                throw new crud_exceptions_1.ValidationFailedException(`the relation "${key}" is not writable`);
+            }
+            delete entity[key];
+            if (value !== null)
+                out.push({ name: key, relation: relations[key], value });
+        }
+        return out;
+    }
+    async insertNested(tx, row, nested, options) {
+        if (!this.config.sql?.useReturning) {
+            throw new crud_exceptions_1.ValidationFailedException("nested writes need RETURNING, which this dialect does not have");
+        }
+        for (const { name, relation, value } of nested) {
+            if (this.isCollection(relation))
+                continue;
+            if (!(0, merge_config_1.isPlainObject)(value)) {
+                throw new crud_exceptions_1.ValidationFailedException(`the relation "${name}" takes an object to create`);
+            }
+            const [parent] = await tx
+                .insert(relation.table)
+                .values(this.relatedRow(relation.table, value, options))
+                .returning();
+            row[relation.localKey] = parent[relation.references ?? "id"];
+        }
+        const created = await this.insertOne(tx, row, options);
+        for (const { name, relation, value } of nested) {
+            if (!this.isCollection(relation))
+                continue;
+            if (!Array.isArray(value)) {
+                throw new crud_exceptions_1.ValidationFailedException(`the relation "${name}" takes an array`);
+            }
+            const parentValue = created[this.parentKeyOf(relation)];
+            if (this.relationType(relation) === "hasMany") {
+                const children = value.map((item) => {
+                    if (!(0, merge_config_1.isPlainObject)(item)) {
+                        throw new crud_exceptions_1.ValidationFailedException(`each "${name}" entry must be an object`);
+                    }
+                    return {
+                        ...this.relatedRow(relation.table, item, options),
+                        [relation.foreignKey]: parentValue,
+                    };
+                });
+                if (children.length > 0) {
+                    await tx.insert(relation.table).values(children);
+                }
+                continue;
+            }
+            const ids = value.filter((item) => !(0, merge_config_1.isPlainObject)(item));
+            const fresh = value.filter((item) => (0, merge_config_1.isPlainObject)(item));
+            if (fresh.length > 0) {
+                const inserted = await tx
+                    .insert(relation.table)
+                    .values(fresh.map((item) => this.relatedRow(relation.table, item, options)))
+                    .returning();
+                ids.push(...inserted.map((r) => r[relation.references ?? "id"]));
+            }
+            await this.linkTargets(tx, relation, parentValue, ids, options);
+        }
+        return created;
+    }
+    relatedRow(table, value, options) {
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            const column = this.columnOf(table, key);
+            if (item === undefined ||
+                !column ||
+                (column.primary && column.hasDefault)) {
+                continue;
+            }
+            out[key] = item;
+        }
+        const softDelete = this.config.softDelete;
+        if (softDelete?.enabled)
+            delete out[softDelete.column];
+        const now = new Date();
+        for (const key of [
+            this.config.timestamps?.createdAt,
+            this.config.timestamps?.updatedAt,
+        ]) {
+            if (key && this.columnOf(table, key))
+                out[key] = now;
+        }
+        for (const [key, item] of Object.entries(this.resolveScope(options) ?? {})) {
+            if (this.columnOf(table, key))
+                out[key] = item;
+        }
+        return out;
+    }
+    async linkTargets(tx, relation, parentValue, ids, options) {
+        const wanted = this.uniqueValues(ids);
+        if (wanted.length === 0)
+            return;
+        const target = relation.table;
+        const referenced = target[relation.references ?? "id"];
+        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 present = new Set(found.map((row) => this.valueKey(row.id)));
+        const missing = wanted.filter((id) => !present.has(this.valueKey(id)));
+        if (missing.length > 0) {
+            const name = this.tableName(target);
+            throw new crud_exceptions_1.BulkOperationException("Unknown related ids", missing.map((id) => ({
+                id,
+                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 already = new Set(linked.map((row) => this.valueKey(row.id)));
+        const add = wanted.filter((id) => !already.has(this.valueKey(id)));
+        if (add.length > 0) {
+            await tx.insert(through).values(add.map((id) => ({
+                [relation.throughLocalKey]: parentValue,
+                [relation.throughForeignKey]: id,
+            })));
+        }
+    }
+    async attach(id, relation, relatedIds, options) {
+        return this.changeLinks("attach", id, relation, relatedIds, options);
+    }
+    async detach(id, relation, relatedIds, options) {
+        return this.changeLinks("detach", id, relation, relatedIds, options);
+    }
+    async sync(id, relation, relatedIds, 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;
+        if (!relation || this.relationType(relation) !== "manyToMany") {
+            throw new common_1.BadRequestException(`"${name}" is not a many-to-many relation of ${this.getEntityName()}`);
+        }
+        const allowed = this.config.writableRelations;
+        if (allowed && !allowed.includes(name) && !options?.skipAllowlists) {
+            throw new crud_exceptions_1.ValidationFailedException(`the relation "${name}" is not writable`);
+        }
+        if (relatedIds !== undefined &&
+            (!Array.isArray(relatedIds) ||
+                relatedIds.some((item) => item === null || typeof item === "object"))) {
+            throw new common_1.BadRequestException(`${operation} takes an array of ids`);
+        }
+        if (operation !== "detach" && relatedIds === undefined) {
+            throw new common_1.BadRequestException(`${operation} takes an array of ids`);
+        }
+        this.checkReadOptions(options);
+        const ids = this.uniqueValues(relatedIds ?? []);
+        const parentKey = this.parentKeyOf(relation);
+        return this.executeSqlTransaction(async (tx) => {
+            const opts = { ...options, transaction: tx };
+            const parent = await this.find(id, {
+                ...opts,
+                relations: [],
+                counts: undefined,
+                select: [this.config.primaryKey, parentKey],
+                skipAllowlists: true,
+            });
+            if (!parent)
+                throw new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id);
+            await this.emitEvent("before", operation, false, { ids: [id], input: relatedIds, transaction: tx }, options);
+            const parentValue = parent[parentKey];
+            const through = relation.through;
+            const local = through[relation.throughLocalKey];
+            const foreign = through[relation.throughForeignKey];
+            if (operation === "detach") {
+                if (relatedIds === undefined) {
+                    await tx.delete(through).where((0, drizzle_orm_1.eq)(local, parentValue));
+                }
+                else if (ids.length > 0) {
+                    await tx
+                        .delete(through)
+                        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(local, parentValue), (0, drizzle_orm_1.inArray)(foreign, ids)));
+                }
+            }
+            else {
+                await this.linkTargets(tx, relation, parentValue, ids, opts);
+                if (operation === "sync") {
+                    await tx
+                        .delete(through)
+                        .where(ids.length > 0
+                        ? (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(local, parentValue), (0, drizzle_orm_1.notInArray)(foreign, ids))
+                        : (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 this.emitEvent("after", operation, false, { ids: [id], input: relatedIds, rows: [row], transaction: tx }, options);
+            return row;
+        }, options?.transaction);
+    }
+    valueKey(value) {
+        return String(value).toLowerCase();
+    }
+    uniqueValues(values) {
+        const seen = new Set();
+        return values.filter((value) => {
+            const key = this.valueKey(value);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+    tableName(table) {
+        try {
+            return (0, drizzle_orm_1.getTableName)(table) || "Entity";
+        }
+        catch {
+            return "Entity";
+        }
+    }
+    prepareUpdate(data, options) {
+        const mapped = this.mapUpdateDtoToEntity(data);
+        if (this.config.versionColumn)
+            delete mapped[this.config.versionColumn];
+        for (const key of Object.keys(this.resolveScope(options) ?? {})) {
+            delete mapped[key];
+        }
+        const entityData = 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) {
+            throw new crud_exceptions_1.ValidationFailedException("there are no columns to update");
+        }
+        return entityData;
+    }
+    async update(id, data, 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);
+        if (this.config.timestamps?.updatedAt) {
+            entityData[this.config.timestamps.updatedAt] = new Date();
+        }
+        const db = transaction || this.config.db;
+        await this.emitEvent("before", "update", false, { ids: [id], input: data, transaction }, options);
+        try {
+            const [updatedEntity] = await this.updateWhereIn(db, this.withVersionBump(entityData), [id], opts);
+            if (!updatedEntity) {
+                if (expected !== undefined) {
+                    throw new crud_exceptions_1.StaleVersionException(this.getEntityName(), id);
+                }
+                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;
+        }
+        catch (error) {
+            throw this.toClientError(error, "write");
+        }
+    }
+    async updateWhereIn(db, set, ids, options) {
+        const query = db
+            .update(this.config.table)
+            .set(set)
+            .where(this.writeWhere(ids, options));
+        if (this.config.sql?.useReturning) {
+            return this.inIdOrder(await query.returning(), ids);
+        }
+        const result = await query;
+        if (!this.wasAffected(result))
+            return [];
+        return this.fetchByIds(db, ids, options);
+    }
+    async fetchByIds(db, ids, options) {
+        const pk = this.config.table[this.config.primaryKey];
+        const rows = await db
+            .select()
+            .from(this.config.table)
+            .where((0, drizzle_orm_1.and)(ids.length === 1 ? (0, drizzle_orm_1.eq)(pk, ids[0]) : (0, drizzle_orm_1.inArray)(pk, ids), ...this.scopeConditions(options)));
+        return this.inIdOrder(rows, ids);
+    }
+    inIdOrder(rows, ids) {
+        const byKey = new Map();
+        for (const row of rows ?? []) {
+            byKey.set(this.keyOf(row?.[this.config.primaryKey]), row);
+        }
+        return ids
+            .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");
+        }
+        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 (!hooks.skipBefore)
+            await this.beforeSoftDelete(id);
+        await this.emitEvent("before", "softDelete", false, { ids: [id], transaction }, options);
+        const db = transaction || this.config.db;
+        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) {
+            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 success;
+    }
+    softDeleteSet(deletedAt) {
+        return this.withVersionBump({
+            [this.config.softDelete.column]: deletedAt,
+            ...(this.config.timestamps?.updatedAt && {
+                [this.config.timestamps.updatedAt]: new Date(),
+            }),
+        });
+    }
+    async restore(id, 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,
+        });
+        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 = transaction || this.config.db;
+        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;
+    }
+    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 = transaction || this.config.db;
+        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");
+        }
+    }
+    async forceDelete(id, options) {
+        return this.delete(id, {
+            ...options,
+            withDeleted: true,
+            onlyDeleted: false,
+        });
+    }
+    async upsert(data, upsert = {}, options) {
+        this.checkReadOptions(options);
+        const entityData = await this.prepareCreate(data, options);
+        const db = options?.transaction || this.config.db;
+        await this.emitEvent("before", "upsert", false, { input: data, transaction: options?.transaction }, options);
+        let row;
+        try {
+            [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) {
+        this.checkReadOptions(options);
+        this.assertBatchSize(this.insertParameters(data));
+        const message = "Mass upsert errors";
+        return this.executeSqlTransaction(async (tx) => {
+            const opts = { ...options, transaction: tx };
+            const rows = await this.eachItem(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);
+            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);
+            return written;
+        }, options?.transaction);
+    }
+    conflictKeys(upsert) {
+        return upsert.conflictTarget === undefined
+            ? [this.config.primaryKey]
+            : [].concat(upsert.conflictTarget);
+    }
+    conflictValue(row, upsert) {
+        return this.conflictKeys(upsert)
+            .map((key) => String(row[key]))
+            .join(", ");
+    }
+    async upsertRows(db, rows, upsert, options) {
+        const table = this.config.table;
+        const targetKeys = this.conflictKeys(upsert);
+        if (targetKeys.length === 0) {
+            throw new common_1.BadRequestException("upsert needs a conflictTarget");
+        }
+        const targets = targetKeys.map((key) => {
+            const column = this.columnOf(table, key);
+            if (!column) {
+                throw new common_1.BadRequestException(`Unknown conflict target column: ${key}`);
+            }
+            return column;
+        });
+        const scope = this.resolveScope(options);
+        const version = this.config.versionColumn;
+        const keep = new Set([
+            ...targetKeys,
+            this.config.primaryKey,
+            this.config.timestamps?.createdAt,
+            version,
+            ...Object.keys(scope ?? {}),
+        ].filter(Boolean));
+        const updateKeys = (upsert.update ??
+            Array.from(new Set(rows.flatMap((row) => Object.keys(row).filter((key) => row[key] !== undefined &&
+                !keep.has(key) &&
+                !!this.columnOf(table, key)))))).filter((key) => key !== version && !(scope && Object.hasOwn(scope, key)));
+        const set = {};
+        for (const key of updateKeys) {
+            const column = this.columnOf(table, key);
+            if (!column) {
+                throw new common_1.BadRequestException(`Unknown upsert column: ${key}`);
+            }
+            set[key] = this.excludedValue(column);
+        }
+        if (Object.keys(set).length === 0) {
+            set[targetKeys[0]] = this.excludedValue(targets[0]);
+        }
+        if (version)
+            set[version] = (0, drizzle_orm_1.sql) `${table[version]} + 1`;
+        const readBack = !this.config.sql?.useReturning;
+        if (readBack) {
+            for (const row of rows) {
+                for (const key of targetKeys) {
+                    if (row[key] === undefined) {
+                        throw new crud_exceptions_1.ValidationFailedException(`upsert needs a value for "${key}" to read the row back`);
+                    }
+                }
+            }
+        }
+        const insert = db.insert(table).values(rows);
+        let statement;
+        if (this.config.dialect === "mysql") {
+            if (scope) {
+                throw new common_1.BadRequestException("upsert on a scoped entity needs PostgreSQL");
+            }
+            statement = insert.onDuplicateKeyUpdate({ set });
+        }
+        else {
+            const guard = [
+                ...this.scopeConditions(options),
+                ...[this.softDeleteCondition(table)].filter(Boolean),
+            ];
+            statement = insert.onConflictDoUpdate({
+                target: targets.length === 1 ? targets[0] : targets,
+                set,
+                ...(guard.length > 0 && { where: (0, drizzle_orm_1.and)(...guard) }),
+            });
+        }
+        if (!readBack)
+            return statement.returning();
+        await statement;
+        const match = rows.map((row) => (0, drizzle_orm_1.and)(...targetKeys.map((key, i) => (0, drizzle_orm_1.eq)(targets[i], row[key]))));
+        const softDeleted = this.softDeleteCondition(table);
+        return db
+            .select()
+            .from(table)
+            .where((0, drizzle_orm_1.and)(match.length === 1 ? match[0] : (0, drizzle_orm_1.or)(...match), ...this.scopeConditions(options), ...(softDeleted ? [softDeleted] : [])));
+    }
+    excludedValue(column) {
+        return this.config.dialect === "mysql"
+            ? (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 massCreate(data, options) {
+        if (options?.bulkMode === "perItem") {
+            return this.massCreatePerItem(data, options);
+        }
+        this.checkReadOptions(options);
+        this.assertBatchSize(this.insertParameters(data));
+        return this.executeSqlTransaction(async (tx) => {
+            const opts = { ...options, transaction: tx };
+            const rows = await this.eachItem(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);
+            const created = await this.runSet(tx, "Mass create errors", (sp) => this.insertMany(sp, rows, opts), rows.map((row, index) => ({
+                index,
+                run: (sp) => this.insertOne(sp, row, opts),
+            })), "write");
+            if (!options?.hooks?.skipAfter) {
+                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) {
+            return db.insert(this.config.table).values(rows).returning();
+        }
+        const pk = this.config.primaryKey;
+        if (rows.every((row) => row[pk] !== undefined)) {
+            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));
+        return created;
+    }
+    assertAllWritten(ids, written, message, options) {
+        if (written.length >= ids.length)
+            return;
+        const done = new Set(written.map((row) => this.keyOf(row?.[this.config.primaryKey])));
+        throw new crud_exceptions_1.BulkOperationException(message, ids
+            .filter((id) => !done.has(this.keyOf(id)))
+            .map((id) => ({
+            id,
+            error: options?.expectedVersions?.[this.keyOf(id)] != null
+                ? new crud_exceptions_1.StaleVersionException(this.getEntityName(), id)
+                : new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id),
+        })));
+    }
+    async massUpdate(ids, data, options) {
+        if (options?.bulkMode === "perItem") {
+            return this.massUpdatePerItem(ids, data, options);
+        }
+        this.assertBatchSize(Array.isArray(ids) ? ids.length : 0);
+        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) => ({
+                id,
+                run: async () => {
+                    await this.validateUpdate(id, data);
+                    const processed = hooks.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);
+            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) {
+                for (const entity of updated)
+                    await this.afterUpdate(entity);
+            }
+            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);
+    }
+    async runKeyed(statement, ids) {
+        if (this.config.sql?.useReturning) {
+            return statement.returning({
+                [this.config.primaryKey]: this.config.table[this.config.primaryKey],
+            });
+        }
+        const result = await statement;
+        return this.wasAffected(result)
+            ? ids.map((id) => ({ [this.config.primaryKey]: id }))
+            : [];
+    }
+    async massSoftDelete(ids, options) {
+        if (!this.config.softDelete?.enabled)
+            throw new common_1.BadRequestException("Soft delete not enabled");
+        if (options?.bulkMode === "perItem") {
+            return this.massSoftDeletePerItem(ids, options);
+        }
+        this.assertBatchSize(Array.isArray(ids) ? ids.length : 0);
+        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
+                    .update(this.config.table)
+                    .set(set)
+                    .where(this.writeWhere([id], opts)),
+            })), "write");
+            this.assertAllWritten(unique, written, message, options);
+            if (!hooks.skipAfter) {
+                for (const id of unique)
+                    await this.afterSoftDelete(id);
+            }
+            await this.emitEvent("after", "softDelete", true, { ids: unique, transaction: tx }, options);
+            return true;
+        }, options?.transaction);
+    }
+    async massRestore(ids, options) {
+        if (!this.config.softDelete?.enabled)
+            throw new common_1.BadRequestException("Soft delete not enabled");
+        if (options?.bulkMode === "perItem") {
+            return this.massRestorePerItem(ids, options);
+        }
+        this.assertBatchSize(Array.isArray(ids) ? ids.length : 0);
+        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) {
+                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) {
+        if (options?.bulkMode === "perItem") {
+            return this.massDeletePerItem(ids, options);
+        }
+        this.assertBatchSize(Array.isArray(ids) ? ids.length : 0);
+        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) {
+                for (const id of unique)
+                    await this.afterDelete(id);
+            }
+            await this.emitEvent("after", "delete", true, { ids: unique, transaction: tx }, options);
+            return true;
+        }, options?.transaction);
+    }
+    async massForceDelete(ids, options) {
+        return this.massDelete(ids, {
+            ...options,
+            withDeleted: true,
+            onlyDeleted: false,
+        });
+    }
+    uniqueIds(ids) {
+        const seen = new Set();
+        return (ids ?? []).filter((id) => {
+            const key = this.keyOf(id);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+    fingerprint(value) {
+        return JSON.stringify(value, (_key, v) => typeof v === "bigint" ? `${v}n` : v);
+    }
+    async assertAllExist(tx, ids, options, message) {
+        const table = this.config.table;
+        const pk = table[this.config.primaryKey];
+        const scope = this.rowScope(options);
+        const where = (condition) => (0, drizzle_orm_1.and)(condition, ...scope);
+        const version = this.config.versionColumn;
+        const fields = { id: pk };
+        if (version)
+            fields.version = table[version];
+        const found = await this.runSet(tx, message, (sp) => sp
+            .select(fields)
+            .from(table)
+            .where(where((0, drizzle_orm_1.inArray)(pk, ids))), ids.map((id) => ({
+            id,
+            run: (sp) => sp
+                .select(fields)
+                .from(table)
+                .where(where((0, drizzle_orm_1.eq)(pk, id))),
+        })), "write");
+        const present = new Map(found.map((row) => [this.keyOf(row.id), row]));
+        const errors = [];
+        for (const id of ids) {
+            const row = present.get(this.keyOf(id));
+            if (!row) {
+                errors.push({
+                    id,
+                    error: new crud_exceptions_1.EntityNotFoundException(this.getEntityName(), id),
+                });
+                continue;
+            }
+            const expected = options.expectedVersions?.[this.keyOf(id)];
+            if (version && expected != null && Number(row.version) !== expected) {
+                errors.push({
+                    id,
+                    error: new crud_exceptions_1.StaleVersionException(this.getEntityName(), id),
+                });
+            }
+        }
+        if (errors.length > 0)
+            throw new crud_exceptions_1.BulkOperationException(message, errors);
+    }
+    async eachItem(items, message, operation = "write") {
+        const results = [];
+        const errors = [];
+        for (const item of items) {
+            try {
+                results.push(await item.run());
+            }
+            catch (error) {
+                errors.push({
+                    ...this.itemRef(item),
+                    error: this.toClientError(error, operation),
+                });
+            }
+        }
+        if (errors.length > 0)
+            throw new crud_exceptions_1.BulkOperationException(message, errors);
+        return results;
+    }
+    itemRef(item) {
+        return item.index !== undefined ? { index: item.index } : { id: item.id };
+    }
+    async runSet(tx, message, statement, items, operation) {
+        try {
+            return await this.savepoint(tx, statement);
+        }
+        catch (error) {
+            const failures = await this.diagnose(tx, items, operation);
+            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 {
+            await this.savepoint(tx, async (outer) => {
+                for (const item of items) {
+                    try {
+                        await this.savepoint(outer, item.run);
+                    }
+                    catch (error) {
+                        failures.push({
+                            ...this.itemRef(item),
+                            error: this.toClientError(error, operation),
+                        });
+                    }
+                }
+                throw ROLLBACK;
+            });
+        }
+        catch (error) {
+            if (error !== ROLLBACK)
+                throw error;
+        }
+        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;
+    }
+    savepoint(tx, run) {
+        return typeof tx?.transaction === "function"
+            ? tx.transaction(run)
+            : run(tx);
+    }
+    async exists(id, options) {
+        const entity = await this.find(id, {
+            ...options,
+            select: [this.config.primaryKey],
+        });
+        return !!entity;
+    }
+    async count(filters, options) {
+        this.checkReadOptions(options);
+        const db = options?.transaction || this.config.db;
+        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);
+    }
+    async countBy(column, filters, options) {
+        this.checkReadOptions(options);
+        const db = options?.transaction || this.config.db;
+        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) {
+            throw new common_1.BadRequestException("countBy needs a column");
+        }
+        const dot = key.indexOf(".");
+        let resolved;
+        if (dot < 0) {
+            const column = this.columnOf(this.config.table, key);
+            if (column)
+                resolved = { column };
+        }
+        else {
+            const name = key.slice(0, dot);
+            const relations = this.config.relations || {};
+            const relation = Object.hasOwn(relations, name)
+                ? relations[name]
+                : undefined;
+            const column = relation && !this.isCollection(relation) && relation.localKey
+                ? this.columnOf(relation.table, key.slice(dot + 1))
+                : undefined;
+            if (column)
+                resolved = { column, relation: name };
+        }
+        if (!resolved) {
+            throw new common_1.BadRequestException(`Unknown countBy column: ${key}`);
+        }
+        this.assertAllowed("filterableColumns", key, options);
+        return resolved;
+    }
+    countNames(counts) {
+        if (!counts)
+            return [];
+        if (Array.isArray(counts))
+            return counts.filter(Boolean);
+        if (!(0, merge_config_1.isPlainObject)(counts)) {
+            throw new common_1.BadRequestException("counts must be a list of relation names or an object of filters");
+        }
+        return Object.keys(counts);
+    }
+    withCountKeys(base, counts) {
+        if (base.length === 0)
+            return base;
+        const keys = this.countNames(counts).flatMap((name) => {
+            const relation = this.config.relations?.[name];
+            return relation ? [this.parentKeyOf(relation)] : [];
+        });
+        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))
+            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;
+            return { name, relation, filter };
+        });
+        const hosts = rows.filter((row) => row && typeof row === "object");
+        for (const host of hosts)
+            host._count = {};
+        if (hosts.length === 0)
+            return;
+        await Promise.all(plan.map(async ({ name, relation, filter }) => {
+            const parentKey = this.parentKeyOf(relation);
+            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));
+                for (const row of result) {
+                    totals.set(String(row[COUNT_KEY]), Number(row.count));
+                }
+            }
+            for (const host of hosts) {
+                host._count[name] = totals.get(String(host[parentKey])) ?? 0;
+            }
+        }));
+    }
+    countQuery(db, relation, ids, name, filter, options) {
+        const target = relation.table;
+        const conditions = [];
+        if (filter) {
+            conditions.push(...this.compileFilterAt({
+                table: target,
+                source: target,
+                relations: relation.relations ?? {},
+                prefix: name,
+                root: false,
+            }, filter, db, new Set(), options));
+        }
+        conditions.push(...this.relatedRowScope(target, options));
+        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))
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.inArray)(joinLocal, ids), ...conditions))
+                .groupBy(joinLocal);
+        }
+        const foreign = target[relation.foreignKey];
+        return db
+            .select({ [COUNT_KEY]: foreign, count: total })
+            .from(target)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.inArray)(foreign, ids), ...conditions))
+            .groupBy(foreign);
+    }
+    pushColumnCondition(conditions, column, value, caseInsensitive = this.config.sql?.caseSensitive === false) {
+        if (Array.isArray(value)) {
+            this.assertBatchSize(value.length);
+            conditions.push((0, drizzle_orm_1.inArray)(column, value.map((item) => this.coerceFilterValue(column, item))));
+        }
+        else if ((0, merge_config_1.isPlainObject)(value)) {
+            this.applyComplexFilter(conditions, column, value);
+        }
+        else {
+            const coerced = this.coerceFilterValue(column, value);
+            if (typeof coerced === "string" &&
+                caseInsensitive &&
+                this.isTextColumn(column)) {
+                conditions.push((0, drizzle_orm_1.sql) `lower(${column}) = lower(${coerced})`);
+            }
+            else {
+                conditions.push((0, drizzle_orm_1.eq)(column, coerced));
+            }
+        }
+    }
+    buildCollectionFilter(relation, value, db = this.config.db, name = "relation", options) {
+        const targetConditions = this.compileFilterAt(this.relationHost(relation, relation.table, name), value, db, new Set(), options);
+        if (targetConditions.length === 0)
+            return undefined;
+        return this.collectionCondition(relation, targetConditions, db, this.rootHost(), options);
+    }
+    collectionCondition(relation, targetConditions, db, host, options) {
+        const target = relation.table;
+        const manyToMany = this.relationType(relation) === "manyToMany";
+        const joinLocal = manyToMany
+            ? relation.through?.[relation.throughLocalKey ?? ""]
+            : undefined;
+        const key = manyToMany ? joinLocal : target[relation.foreignKey ?? ""];
+        if (!key)
+            return undefined;
+        const conditions = [...targetConditions];
+        conditions.push(...this.relatedRowScope(target, options));
+        let subquery;
+        if (manyToMany) {
+            const referenced = target[relation.references ?? "id"];
+            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));
+        }
+        else {
+            subquery = db
+                .select({ value: key })
+                .from(target)
+                .where((0, drizzle_orm_1.and)(...conditions));
+        }
+        const parentKey = this.parentKeyOf(relation, host.source);
+        return (0, drizzle_orm_1.inArray)(host.table[parentKey], subquery);
+    }
+    quantifiedCollection(quantifier, relation, inner, name, db, host, options) {
+        const target = subqueryAlias(relation.table);
+        const compiled = this.compileFilterAt(this.relationHost(relation, target, name), inner, db, new Set(), options);
+        if (quantifier === "every" && compiled.length === 0)
+            return undefined;
+        const parentKey = this.parentKeyOf(relation, host.source);
+        const conditions = [];
+        conditions.push(...this.relatedRowScope(target, options));
+        if (compiled.length > 0) {
+            const matched = (0, drizzle_orm_1.and)(...compiled);
+            conditions.push(quantifier === "every"
+                ? (0, drizzle_orm_1.not)((0, drizzle_orm_1.sql) `coalesce(${matched}, false)`)
+                : matched);
+        }
+        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));
+        }
+        else {
+            subquery = db
+                .select({ one: (0, drizzle_orm_1.sql) `1` })
+                .from(target)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(target[relation.foreignKey], host.table[parentKey]), ...conditions));
+        }
+        return (0, drizzle_orm_1.notExists)(subquery);
+    }
+    belongsToExists(relation, inner, name, db, host, options) {
+        const target = subqueryAlias(relation.table);
+        const compiled = this.compileFilterAt(this.relationHost(relation, target, name), inner, db, new Set(), options);
+        if (compiled.length === 0)
+            return undefined;
+        return (0, drizzle_orm_1.exists)(db
+            .select({ one: (0, drizzle_orm_1.sql) `1` })
+            .from(target)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(target[relation.references ?? "id"], host.table[relation.localKey]), ...compiled, ...this.relatedRowScope(target, options))));
+    }
+    rootHost() {
+        return {
+            table: this.config.table,
+            source: this.config.table,
+            relations: this.config.relations || {},
+            prefix: "",
+            root: true,
+        };
+    }
+    relationHost(relation, table, path) {
+        return {
+            table,
+            source: relation.table,
+            relations: relation.relations ?? {},
+            prefix: path,
+            root: false,
+        };
+    }
+    buildFilterConditions(filters, db = this.config.db, options) {
+        (0, query_parser_1.assertFilterDepth)(filters);
+        const joins = new Set();
+        const conditions = this.compileFilterAt(this.rootHost(), filters, db, joins, options);
+        return { conditions, relations: Array.from(joins) };
+    }
+    isGroupKey(host, key) {
+        if (!GROUP_KEYS.has(key) || this.columnOf(host.source, key))
+            return false;
+        return !Object.hasOwn(host.relations, key);
+    }
+    compileFilterAt(host, filters, db, joins, options) {
+        const conditions = [];
+        if (filters === undefined || filters === null)
+            return conditions;
+        if (!(0, merge_config_1.isPlainObject)(filters)) {
+            throw new common_1.BadRequestException("A filter must be an object");
+        }
+        const path = (key) => (host.prefix ? `${host.prefix}.${key}` : key);
+        for (const [key, value] of Object.entries(filters)) {
+            if (value === undefined || value === null)
+                continue;
+            if (this.isGroupKey(host, key)) {
+                const group = this.compileGroup(key, value, (member) => this.compileFilterAt(host, member, db, joins, options));
+                if (group)
+                    conditions.push(group);
+                continue;
+            }
+            const column = this.columnOf(host.source, key);
+            const relation = !column && Object.hasOwn(host.relations, key)
+                ? host.relations[key]
+                : undefined;
+            if (relation) {
+                if (!(0, merge_config_1.isPlainObject)(value)) {
+                    throw new common_1.BadRequestException(`Filter on relation "${path(key)}" must be an object of column filters`);
+                }
+                const condition = this.compileRelationFilter(host, key, relation, value, db, joins, options);
+                if (condition)
+                    conditions.push(condition);
+                continue;
+            }
+            if (!column) {
+                throw new common_1.BadRequestException(`Unknown filter column: ${path(key)}`);
+            }
+            this.assertAllowed("filterableColumns", path(key), options);
+            this.pushColumnCondition(conditions, host.table[key] ?? column, value);
+        }
+        return conditions;
+    }
+    compileRelationFilter(host, name, relation, value, db, joins, options) {
+        const path = host.prefix ? `${host.prefix}.${name}` : name;
+        if (!this.isCollection(relation)) {
+            if (host.root && relation.localKey) {
+                const inner = this.compileFilterAt(this.relationHost(relation, relation.table, path), value, db, joins, options);
+                if (inner.length === 0)
+                    return undefined;
+                joins.add(name);
+                return inner.length === 1 ? inner[0] : (0, drizzle_orm_1.and)(...inner);
+            }
+            return this.belongsToExists(relation, value, path, db, host, options);
+        }
+        const keys = Object.keys(value);
+        const quantified = keys.length > 0 &&
+            keys.every((key) => QUANTIFIERS.has(key) && !this.columnOf(relation.table, key));
+        const parts = [];
+        const quantifiers = quantified
+            ? Object.entries(value)
+            : [["some", value]];
+        for (const [quantifier, inner] of quantifiers) {
+            if (inner === undefined || inner === null)
+                continue;
+            if (!(0, merge_config_1.isPlainObject)(inner)) {
+                throw new common_1.BadRequestException(`Filter "${path}.${quantifier}" must be an object of column filters`);
+            }
+            if (quantifier === "some") {
+                const compiled = this.compileFilterAt(this.relationHost(relation, relation.table, path), inner, db, new Set(), options);
+                if (compiled.length === 0 && !quantified)
+                    continue;
+                const condition = this.collectionCondition(relation, compiled, db, host, options);
+                if (condition)
+                    parts.push(condition);
+            }
+            else {
+                const condition = this.quantifiedCollection(quantifier, relation, inner, path, db, host, options);
+                if (condition)
+                    parts.push(condition);
+            }
+        }
+        if (parts.length === 0)
+            return undefined;
+        return parts.length === 1 ? parts[0] : (0, drizzle_orm_1.and)(...parts);
+    }
+    compileGroup(op, value, compile) {
+        if (op === "not") {
+            if (!(0, merge_config_1.isPlainObject)(value)) {
+                throw new common_1.BadRequestException('Filter group "not" expects a filter object');
+            }
+            const inner = compile(value);
+            return inner.length > 0 ? (0, drizzle_orm_1.not)((0, drizzle_orm_1.and)(...inner)) : undefined;
+        }
+        if (!Array.isArray(value)) {
+            throw new common_1.BadRequestException(`Filter group "${op}" expects an array of filter objects`);
+        }
+        const parts = [];
+        for (const member of value) {
+            if (!(0, merge_config_1.isPlainObject)(member)) {
+                throw new common_1.BadRequestException(`Filter group "${op}" expects an array of filter objects`);
+            }
+            const inner = compile(member);
+            if (inner.length === 0) {
+                if (op === "or")
+                    return undefined;
+                continue;
+            }
+            parts.push(inner.length === 1 ? inner[0] : (0, drizzle_orm_1.and)(...inner));
+        }
+        if (parts.length === 0)
+            return undefined;
+        return op === "or" ? (0, drizzle_orm_1.or)(...parts) : (0, drizzle_orm_1.and)(...parts);
+    }
+    buildWhereConditions(filters) {
+        return this.buildFilterConditions(filters).conditions;
+    }
+    parseFlag(op, value) {
+        if (value === true || value === "true")
+            return true;
+        if (value === false || value === "false")
+            return false;
+        throw new common_1.BadRequestException(`Invalid value for "${op}": expected true or false`);
+    }
+    expectArray(op, raw) {
+        if (!Array.isArray(raw)) {
+            throw new common_1.BadRequestException(`Filter operator "${op}" expects an array`);
+        }
+        this.assertBatchSize(raw.length);
+        return raw;
+    }
+    static MAX_BATCH_PARAMETERS = 60_000;
+    assertBatchSize(parameters) {
+        const max = SqlBaseCrudService.MAX_BATCH_PARAMETERS;
+        if (parameters > max) {
+            throw new common_1.BadRequestException(`Too many values in one call (${parameters}); the limit is ${max}. Split the batch.`);
+        }
+    }
+    insertParameters(rows) {
+        let widest = 0;
+        for (const row of rows) {
+            if ((0, merge_config_1.isPlainObject)(row))
+                widest = Math.max(widest, Object.keys(row).length);
+        }
+        return rows.length * (widest + 4);
+    }
+    requirePostgres(op) {
+        if (this.config.dialect !== "postgresql") {
+            throw new common_1.BadRequestException(`Filter operator "${op}" is only supported on PostgreSQL`);
+        }
+    }
+    patternCondition(column, op, raw) {
+        if (typeof raw !== "string") {
+            throw new common_1.BadRequestException(`Filter operator "${op}" expects a string`);
+        }
+        if (!this.isTextColumn(column)) {
+            throw new common_1.BadRequestException(`Filter operator "${op}" only works on text columns`);
+        }
+        const insensitive = /^i[A-Z]/.test(op);
+        const kind = insensitive ? op[1].toLowerCase() + op.slice(2) : op;
+        const escaped = raw.replace(/[\\%_]/g, "\\$&");
+        const pattern = kind === "startsWith"
+            ? `${escaped}%`
+            : kind === "endsWith"
+                ? `%${escaped}`
+                : `%${escaped}%`;
+        return insensitive || this.config.sql?.caseSensitive === false
+            ? this.caseInsensitiveLike(column, pattern)
+            : (0, drizzle_orm_1.like)(column, pattern);
+    }
+    applyComplexFilter(conditions, column, filterObj) {
+        const coerce = (value) => this.coerceFilterValue(column, value);
+        for (const [op, raw] of Object.entries(filterObj)) {
+            if (raw === undefined)
+                continue;
+            if ((op === "gt" || op === "gte" || op === "lt" || op === "lte") &&
+                typeof raw === "number" &&
+                !Number.isFinite(raw)) {
+                throw new common_1.BadRequestException(`Invalid numeric filter operand for "${op}": ${raw}`);
+            }
+            switch (op) {
+                case "eq":
+                    conditions.push((0, drizzle_orm_1.eq)(column, coerce(raw)));
+                    break;
+                case "gt":
+                    conditions.push((0, drizzle_orm_1.gt)(column, coerce(raw)));
+                    break;
+                case "gte":
+                    conditions.push((0, drizzle_orm_1.gte)(column, coerce(raw)));
+                    break;
+                case "lt":
+                    conditions.push((0, drizzle_orm_1.lt)(column, coerce(raw)));
+                    break;
+                case "lte":
+                    conditions.push((0, drizzle_orm_1.lte)(column, coerce(raw)));
+                    break;
+                case "neq":
+                    conditions.push((0, drizzle_orm_1.ne)(column, coerce(raw)));
+                    break;
+                case "like":
+                    conditions.push((0, drizzle_orm_1.like)(column, raw));
+                    break;
+                case "ilike":
+                    conditions.push(this.caseInsensitiveLike(column, raw));
+                    break;
+                case "in":
+                    conditions.push((0, drizzle_orm_1.inArray)(column, this.expectArray(op, raw).map(coerce)));
+                    break;
+                case "notIn":
+                    conditions.push((0, drizzle_orm_1.notInArray)(column, this.expectArray(op, raw).map(coerce)));
+                    break;
+                case "between": {
+                    const range = this.expectArray(op, raw);
+                    if (range.length !== 2) {
+                        throw new common_1.BadRequestException('Filter operator "between" expects [from, to]');
+                    }
+                    conditions.push((0, drizzle_orm_1.between)(column, coerce(range[0]), coerce(range[1])));
+                    break;
+                }
+                case "isNull":
+                    conditions.push(this.parseFlag(op, raw) ? (0, drizzle_orm_1.isNull)(column) : (0, drizzle_orm_1.isNotNull)(column));
+                    break;
+                case "isNotNull":
+                    conditions.push(this.parseFlag(op, raw) ? (0, drizzle_orm_1.isNotNull)(column) : (0, drizzle_orm_1.isNull)(column));
+                    break;
+                case "startsWith":
+                case "endsWith":
+                case "contains":
+                case "iStartsWith":
+                case "iEndsWith":
+                case "iContains":
+                    conditions.push(this.patternCondition(column, op, raw));
+                    break;
+                case "arrayContains":
+                case "arrayOverlaps": {
+                    this.requirePostgres(op);
+                    if (column?.dataType !== "array") {
+                        throw new common_1.BadRequestException(`Filter operator "${op}" only works on array columns`);
+                    }
+                    const values = this.expectArray(op, raw);
+                    conditions.push(op === "arrayContains"
+                        ? (0, drizzle_orm_1.arrayContains)(column, values)
+                        : (0, drizzle_orm_1.arrayOverlaps)(column, values));
+                    break;
+                }
+                case "jsonContains":
+                    this.requirePostgres(op);
+                    if (column?.columnType !== "PgJsonb") {
+                        throw new common_1.BadRequestException('Filter operator "jsonContains" only works on jsonb columns');
+                    }
+                    conditions.push((0, drizzle_orm_1.sql) `${column} @> ${JSON.stringify(raw)}::jsonb`);
+                    break;
+                default:
+                    throw new common_1.BadRequestException(`Unknown filter operator: ${op}`);
+            }
+        }
+    }
+    async executeSqlTransaction(operation, existingTransaction) {
+        if (existingTransaction)
+            return operation(existingTransaction);
+        return this.config.db.transaction(operation);
+    }
+    getEntityName() {
+        try {
+            return (0, drizzle_orm_1.getTableName)(this.config.table) || "Entity";
+        }
+        catch {
+            return "Entity";
+        }
+    }
+    async fullTextSearch(searchTerm, searchColumns, pagination, 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}`);
+            }
+            this.assertAllowed("searchableColumns", name, options);
+            return column;
+        });
+        const { transaction } = options || {};
+        const db = transaction || this.config.db;
+        const tsVector = drizzle_orm_1.sql.join(columns.map((column) => (0, drizzle_orm_1.sql) `to_tsvector('english', ${column})`), (0, drizzle_orm_1.sql) ` || `);
+        const tsQuery = (0, drizzle_orm_1.sql) `plainto_tsquery('english', ${searchTerm})`;
+        const matchExpr = (0, drizzle_orm_1.sql) `${tsVector} @@ ${tsQuery}`;
+        const whereExpr = (0, drizzle_orm_1.and)(matchExpr, ...this.rowScope(options));
+        const { page, limit, offset } = this.resolvePagination(pagination?.page, pagination?.limit);
+        const pk = this.columnOf(this.config.table, this.config.primaryKey);
+        const orderBy = [(0, drizzle_orm_1.sql) `ts_rank(${tsVector}, ${tsQuery}) DESC`];
+        if (pk)
+            orderBy.push((0, drizzle_orm_1.asc)(pk));
+        const dataQuery = db
+            .select()
+            .from(this.config.table)
+            .where(whereExpr)
+            .orderBy(...orderBy)
+            .limit(limit)
+            .offset(offset);
+        const countQuery = db
+            .select({ count: (0, drizzle_orm_1.sql) `count(*)` })
+            .from(this.config.table)
+            .where(whereExpr);
+        const [data, totalResult] = await this.runRead(Promise.all([dataQuery, countQuery]));
+        const total = parseInt(totalResult[0]?.count?.toString() || "0", 10);
+        return { data, total, page, limit };
+    }
+}
+exports.SqlBaseCrudService = SqlBaseCrudService;
+//# sourceMappingURL=sql-base-crud.service.js.map