@relq/orm 0.1.3 → 0.1.5

package/dist/cjs/mysql/helpers/MysqlConnectedTransactionBuilder.cjs

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlTransactionClient = void 0;
+exports.executeMysqlTransaction = executeMysqlTransaction;
+const MysqlConnectedRawQueryBuilder_1 = require("./MysqlConnectedRawQueryBuilder.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+class MysqlTransactionClient {
+    client;
+    relq;
+    schema;
+    constructor(client, relq) {
+        this.client = client;
+        this.relq = relq;
+        const internal = this.relq[methods_1.INTERNAL];
+        this.schema = internal.getSchema?.() ?? this.relq.schema;
+    }
+    get dialect() { return this.relq.dialect; }
+    get capabilities() { return this.relq.capabilities; }
+    get table() {
+        const { createMysqlTableAccessor } = require("../shared/mysql-table-accessor.cjs");
+        return createMysqlTableAccessor(this, this.schema);
+    }
+    raw(query, ...params) {
+        return new MysqlConnectedRawQueryBuilder_1.MysqlConnectedRawQueryBuilder(query, params, this);
+    }
+    async savepoint(name) {
+        await this.executeOnClient(`SAVEPOINT \`${name}\``);
+    }
+    async rollbackTo(name) {
+        await this.executeOnClient(`ROLLBACK TO SAVEPOINT \`${name}\``);
+    }
+    async releaseSavepoint(name) {
+        await this.executeOnClient(`RELEASE SAVEPOINT \`${name}\``);
+    }
+    async executeOnClient(sql) {
+        const [rows, fields] = await this.client.query(sql);
+        return {
+            rows: Array.isArray(rows) ? rows : [],
+            rowCount: rows?.affectedRows ?? 0,
+            command: sql.split(' ')[0] || 'QUERY',
+            fields: (fields ?? []).map((f) => ({ name: f.name, dataTypeID: f.columnType ?? 0 })),
+        };
+    }
+    get [methods_1.INTERNAL]() {
+        const parentInternal = this.relq[methods_1.INTERNAL];
+        const queryViaClient = async (sql) => {
+            const start = performance.now();
+            const result = await this.executeOnClient(sql);
+            return { result, duration: performance.now() - start };
+        };
+        const buildMetadata = (result, duration) => ({
+            rowCount: result.rowCount,
+            command: result.command,
+            duration,
+            fields: result.fields,
+        });
+        return {
+            executeQuery: queryViaClient,
+            async executeSelect(sql, tableName) {
+                const { result, duration } = await queryViaClient(sql);
+                const rows = tableName
+                    ? parentInternal.transformResultsFromDb(tableName, result.rows)
+                    : result.rows;
+                return { data: rows, metadata: buildMetadata(result, duration) };
+            },
+            async executeSelectOne(sql, tableName) {
+                const { result, duration } = await queryViaClient(sql);
+                const row = result.rows[0]
+                    ? (tableName ? parentInternal.transformFromDbColumns(tableName, result.rows[0]) : result.rows[0])
+                    : null;
+                return { data: row, metadata: buildMetadata(result, duration) };
+            },
+            async executeCount(sql) {
+                const { result, duration } = await queryViaClient(sql);
+                const count = result.rows[0]?.count
+                    ? parseInt(result.rows[0].count, 10)
+                    : 0;
+                return { count, metadata: buildMetadata(result, duration) };
+            },
+            async executeRun(sql) {
+                const { result, duration } = await queryViaClient(sql);
+                return { success: true, metadata: buildMetadata(result, duration) };
+            },
+            executeRawQuery: queryViaClient,
+            transformToDbColumns: parentInternal.transformToDbColumns,
+            transformFromDbColumns: parentInternal.transformFromDbColumns,
+            transformResultsFromDb: parentInternal.transformResultsFromDb,
+            hasColumnMapping: parentInternal.hasColumnMapping,
+            validateData: parentInternal.validateData,
+            getSchema: parentInternal.getSchema,
+            getRelations: parentInternal.getRelations,
+            getTableDef: parentInternal.getTableDef,
+            getClientForCursor: async () => ({ client: this.client, release: () => { } }),
+        };
+    }
+}
+exports.MysqlTransactionClient = MysqlTransactionClient;
+async function executeMysqlTransaction(relq, callback, options) {
+    await relq.ensureInitialized();
+    const { client, release } = await relq[methods_1.INTERNAL].getClientForCursor();
+    try {
+        if (options?.isolation) {
+            await client.query(`SET TRANSACTION ISOLATION LEVEL ${options.isolation}`);
+        }
+        let startSql = 'START TRANSACTION';
+        if (options?.readOnly === true) {
+            startSql += ' READ ONLY';
+        }
+        else if (options?.readOnly === false) {
+            startSql += ' READ WRITE';
+        }
+        await client.query(startSql);
+        const tx = new MysqlTransactionClient(client, relq);
+        const result = await callback(tx);
+        await client.query('COMMIT');
+        return result;
+    }
+    catch (error) {
+        try {
+            await client.query('ROLLBACK');
+        }
+        catch { }
+        throw error;
+    }
+    finally {
+        release();
+    }
+}

package/dist/cjs/mysql/helpers/MysqlConnectedUpdateBuilder.cjs

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlConnectedUpdateBuilder = void 0;
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+class MysqlConnectedUpdateBuilder {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey)
+            return;
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef)
+            return;
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
+    }
+    set(data) {
+        this.builder.set(data);
+        return this;
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.MysqlConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable) {
+                const matches = conditionTable === this.schemaKey || conditionTable === this.tableName;
+                if (!matches) {
+                    const queryTable = this.schemaKey || this.tableName;
+                    throw new relq_errors_1.RelqBuilderError(`Condition was created for table '${conditionTable}' but is being used on '${queryTable}'. ` +
+                        `Create the condition with db.where('${queryTable}') instead.`);
+                }
+            }
+            this.builder.where(callbackOrCondition);
+            return this;
+        }
+        const callback = callbackOrCondition;
+        this.builder.where((q) => {
+            return callback(q);
+        });
+        return this;
+    }
+    join(table, condition) {
+        this.builder.join(table, condition);
+        return this;
+    }
+    leftJoin(table, condition) {
+        this.builder.leftJoin(table, condition);
+        return this;
+    }
+    innerJoin(table, condition) {
+        this.builder.innerJoin(table, condition);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.builder.orderBy(column, direction);
+        return this;
+    }
+    limit(count) {
+        this.builder.limit(count);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        this.relq[methods_1.INTERNAL].validateData(this.builder.tableName, this.builder.updateData, 'update');
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+}
+exports.MysqlConnectedUpdateBuilder = MysqlConnectedUpdateBuilder;

package/dist/cjs/mysql/helpers/MysqlPaginateBuilder.cjs

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlPaginateBuilder = void 0;
+const count_builder_1 = require("../count/count-builder.cjs");
+const select_builder_1 = require("../select/select-builder.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+class MysqlPaginateBuilder {
+    relq;
+    tableName;
+    columns;
+    whereClause;
+    orderByClause;
+    constructor(relq, tableName, columns, whereClause, orderByClause) {
+        this.relq = relq;
+        this.tableName = tableName;
+        this.columns = columns;
+        this.whereClause = whereClause;
+        this.orderByClause = orderByClause;
+    }
+    async paging(options) {
+        const page = options.page ?? 1;
+        const perPage = options.perPage;
+        const shouldCount = options.count ?? true;
+        if (page < 1) {
+            throw new relq_errors_1.RelqBuilderError('page must be >= 1', { builder: 'paginate', hint: 'Page numbers are 1-indexed, starting from 1' });
+        }
+        if (perPage < 1) {
+            throw new relq_errors_1.RelqBuilderError('perPage must be >= 1', { builder: 'paginate', hint: 'Set perPage to the number of items you want per page (e.g. 20)' });
+        }
+        const columnsToSelect = this.columns && this.columns.length > 0 ? this.columns : ['*'];
+        const orderByArr = this.orderByClause
+            ? (Array.isArray(this.orderByClause[0]) ? this.orderByClause : [this.orderByClause])
+            : [];
+        const selectBuilder = new select_builder_1.MysqlSelectBuilder(this.tableName, columnsToSelect);
+        if (this.whereClause) {
+            selectBuilder.where(this.whereClause);
+        }
+        for (const [column, direction] of orderByArr) {
+            const dbColumn = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [column]: true });
+            selectBuilder.orderBy(Object.keys(dbColumn)[0] || column, direction);
+        }
+        let total = 0;
+        if (shouldCount) {
+            const countBuilder = new count_builder_1.MysqlCountBuilder(this.tableName);
+            if (this.whereClause) {
+                countBuilder.where(this.whereClause);
+            }
+            const countResult = await this.relq[methods_1.INTERNAL].executeCount(countBuilder.toString());
+            total = countResult.count;
+        }
+        const offset = (page - 1) * perPage;
+        selectBuilder.limit(perPage);
+        selectBuilder.offset(offset);
+        const result = await this.relq[methods_1.INTERNAL].executeSelect(selectBuilder.toString(), this.tableName);
+        const totalPages = Math.ceil(total / perPage);
+        const hasNext = page < totalPages;
+        const hasPrev = page > 1;
+        const pagination = {
+            page,
+            perPage,
+            total,
+            totalPages,
+        };
+        if (hasNext) {
+            pagination.hasNext = true;
+            pagination.nextPage = page + 1;
+            Object.defineProperty(pagination, 'loadNext', {
+                value: () => this.paging({ ...options, page: page + 1 }),
+                enumerable: false,
+            });
+        }
+        else {
+            pagination.hasNext = false;
+        }
+        if (hasPrev) {
+            pagination.hasPrev = true;
+            pagination.prevPage = page - 1;
+            Object.defineProperty(pagination, 'loadPrev', {
+                value: () => this.paging({ ...options, page: page - 1 }),
+                enumerable: false,
+            });
+        }
+        else {
+            pagination.hasPrev = false;
+        }
+        Object.defineProperty(pagination, 'toJSON', {
+            value: () => ({
+                page, perPage, total, totalPages,
+                hasNext: pagination.hasNext, hasPrev: pagination.hasPrev,
+                nextPage: pagination.nextPage, prevPage: pagination.prevPage,
+            }),
+            enumerable: false,
+        });
+        return { data: result.data, pagination };
+    }
+    async offset(options) {
+        const position = options.position ?? 0;
+        const shouldCount = options.count ?? false;
+        if (position < 0) {
+            throw new relq_errors_1.RelqBuilderError('position must be >= 0', { builder: 'paginate', hint: 'Position is 0-indexed; use 0 for the first row' });
+        }
+        let limit;
+        if (options.shuffleLimit) {
+            const [min, max] = options.shuffleLimit;
+            if (min < 1 || max < 1) {
+                throw new relq_errors_1.RelqBuilderError('shuffleLimit values must be >= 1', { builder: 'paginate', hint: 'Both min and max in shuffleLimit must be positive integers' });
+            }
+            if (min > max) {
+                throw new relq_errors_1.RelqBuilderError('shuffleLimit[0] must be <= shuffleLimit[1]', { builder: 'paginate', hint: 'The first value (min) must be less than or equal to the second value (max)' });
+            }
+            limit = Math.floor(Math.random() * (max - min + 1)) + min;
+        }
+        else {
+            const limitValue = options.limit;
+            if (limitValue !== undefined && limitValue < 1) {
+                throw new relq_errors_1.RelqBuilderError('limit must be >= 1', { builder: 'paginate', hint: 'Set limit to a positive integer for the number of rows to fetch' });
+            }
+            limit = limitValue ?? 50;
+        }
+        const columnsToSelect = this.columns && this.columns.length > 0 ? this.columns : ['*'];
+        const orderByArr = this.orderByClause
+            ? (Array.isArray(this.orderByClause[0]) ? this.orderByClause : [this.orderByClause])
+            : [];
+        const selectBuilder = new select_builder_1.MysqlSelectBuilder(this.tableName, columnsToSelect);
+        if (this.whereClause) {
+            selectBuilder.where(this.whereClause);
+        }
+        for (const [column, direction] of orderByArr) {
+            const dbColumn = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [column]: true });
+            selectBuilder.orderBy(Object.keys(dbColumn)[0] || column, direction);
+        }
+        let total = 0;
+        if (shouldCount) {
+            const countBuilder = new count_builder_1.MysqlCountBuilder(this.tableName);
+            if (this.whereClause) {
+                countBuilder.where(this.whereClause);
+            }
+            const countResult = await this.relq[methods_1.INTERNAL].executeCount(countBuilder.toString());
+            total = countResult.count;
+        }
+        selectBuilder.limit(limit + 1);
+        selectBuilder.offset(position);
+        const result = await this.relq[methods_1.INTERNAL].executeSelect(selectBuilder.toString(), this.tableName);
+        const hasMore = result.data.length > limit;
+        const data = hasMore ? result.data.slice(0, limit) : result.data;
+        const hasPrev = position > 0;
+        const pagination = {
+            position,
+            limit,
+            total,
+        };
+        if (hasMore) {
+            pagination.hasMore = true;
+            pagination.nextPos = position + limit;
+            Object.defineProperty(pagination, 'loadNext', {
+                value: () => this.offset({ ...options, position: position + limit }),
+                enumerable: false,
+            });
+        }
+        else {
+            pagination.hasMore = false;
+        }
+        if (hasPrev) {
+            pagination.hasPrev = true;
+            pagination.prevPos = Math.max(0, position - limit);
+            Object.defineProperty(pagination, 'loadPrev', {
+                value: () => this.offset({ ...options, position: Math.max(0, position - limit) }),
+                enumerable: false,
+            });
+        }
+        else {
+            pagination.hasPrev = false;
+        }
+        Object.defineProperty(pagination, 'toJSON', {
+            value: () => ({
+                position, limit, total,
+                hasMore: pagination.hasMore, hasPrev: pagination.hasPrev,
+                nextPos: pagination.nextPos, prevPos: pagination.prevPos,
+            }),
+            enumerable: false,
+        });
+        return { data, pagination };
+    }
+}
+exports.MysqlPaginateBuilder = MysqlPaginateBuilder;

package/dist/cjs/mysql/helpers/MysqlReturningExecutor.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlReturningExecutor = void 0;
+const insert_builder_1 = require("../insert/insert-builder.cjs");
+const methods_1 = require("../../core/helpers/methods.cjs");
+const capability_guard_1 = require("../../core/helpers/capability-guard.cjs");
+class MysqlReturningExecutor {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    columnMapping;
+    constructor(builder, relq, tableName, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        (0, capability_guard_1.requireCapability)(relq, 'returning', 'RETURNING clause (MariaDB 10.5+ only)');
+        this.setupColumnMapping();
+    }
+    setupColumnMapping() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.columnMapping = new Map();
+        for (const [propName, columnDef] of Object.entries(tableColumns)) {
+            if (columnDef && typeof columnDef === 'object') {
+                const sqlName = columnDef.$columnName || propName;
+                this.columnMapping.set(sqlName, propName);
+            }
+        }
+    }
+    transformRow(row) {
+        if (!this.columnMapping) {
+            return row;
+        }
+        const transformed = {};
+        for (const [sqlKey, value] of Object.entries(row)) {
+            const propName = this.columnMapping.get(sqlKey) || sqlKey;
+            transformed[propName] = value;
+        }
+        return transformed;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        const internal = this.relq[methods_1.INTERNAL];
+        if (this.builder instanceof insert_builder_1.MysqlInsertBuilder) {
+            for (const row of this.builder.insertData) {
+                internal.validateData(this.builder.tableName, row, 'insert');
+            }
+        }
+        const sql = this.builder.toString();
+        const result = await internal.executeSelect(sql);
+        const transformedData = result.data.map(row => this.transformRow(row));
+        if (withMetadata) {
+            return { ...result, data: transformedData };
+        }
+        return transformedData;
+    }
+}
+exports.MysqlReturningExecutor = MysqlReturningExecutor;

package/dist/cjs/mysql/helpers/index.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMysqlPrimaryKeyColumn = exports.executeMysqlRestore = exports.executeMysqlSoftDelete = exports.executeMysqlCreateWith = exports.executeMysqlUpsert = exports.executeMysqlExists = exports.executeMysqlFindMany = exports.executeMysqlFindOne = exports.executeMysqlFindById = exports.executeMysqlPagination = exports.executeMysqlCursorEach = exports.executeMysqlJoinManyThrough = exports.executeMysqlCorrelatedSubqueryJoin = exports.executeMysqlTypeSafeJoin = exports.MysqlPaginateBuilder = exports.MysqlConnectedQueryBuilder = exports.MysqlConnectedSelectBuilder = exports.MysqlConnectedInsertFromSelectBuilder = exports.NativeCTEBuilder = exports.MysqlConnectedAggregateBuilder = exports.MysqlConnectedInsertBuilder = exports.MysqlConnectedUpdateBuilder = exports.MysqlConnectedDeleteBuilder = exports.executeMysqlTransaction = exports.MysqlTransactionClient = exports.MysqlConnectedCountBuilder = exports.MysqlConnectedRawQueryBuilder = void 0;
+var MysqlConnectedRawQueryBuilder_1 = require("./MysqlConnectedRawQueryBuilder.cjs");
+Object.defineProperty(exports, "MysqlConnectedRawQueryBuilder", { enumerable: true, get: function () { return MysqlConnectedRawQueryBuilder_1.MysqlConnectedRawQueryBuilder; } });
+var MysqlConnectedCountBuilder_1 = require("./MysqlConnectedCountBuilder.cjs");
+Object.defineProperty(exports, "MysqlConnectedCountBuilder", { enumerable: true, get: function () { return MysqlConnectedCountBuilder_1.MysqlConnectedCountBuilder; } });
+var MysqlConnectedTransactionBuilder_1 = require("./MysqlConnectedTransactionBuilder.cjs");
+Object.defineProperty(exports, "MysqlTransactionClient", { enumerable: true, get: function () { return MysqlConnectedTransactionBuilder_1.MysqlTransactionClient; } });
+Object.defineProperty(exports, "executeMysqlTransaction", { enumerable: true, get: function () { return MysqlConnectedTransactionBuilder_1.executeMysqlTransaction; } });
+var MysqlConnectedDeleteBuilder_1 = require("./MysqlConnectedDeleteBuilder.cjs");
+Object.defineProperty(exports, "MysqlConnectedDeleteBuilder", { enumerable: true, get: function () { return MysqlConnectedDeleteBuilder_1.MysqlConnectedDeleteBuilder; } });
+var MysqlConnectedUpdateBuilder_1 = require("./MysqlConnectedUpdateBuilder.cjs");
+Object.defineProperty(exports, "MysqlConnectedUpdateBuilder", { enumerable: true, get: function () { return MysqlConnectedUpdateBuilder_1.MysqlConnectedUpdateBuilder; } });
+var MysqlConnectedInsertBuilder_1 = require("./MysqlConnectedInsertBuilder.cjs");
+Object.defineProperty(exports, "MysqlConnectedInsertBuilder", { enumerable: true, get: function () { return MysqlConnectedInsertBuilder_1.MysqlConnectedInsertBuilder; } });
+var MysqlConnectedAggregateBuilder_1 = require("./MysqlConnectedAggregateBuilder.cjs");
+Object.defineProperty(exports, "MysqlConnectedAggregateBuilder", { enumerable: true, get: function () { return MysqlConnectedAggregateBuilder_1.MysqlConnectedAggregateBuilder; } });
+var native_cte_builder_1 = require("../../core/cte/native-cte-builder.cjs");
+Object.defineProperty(exports, "NativeCTEBuilder", { enumerable: true, get: function () { return native_cte_builder_1.NativeCTEBuilder; } });
+var MysqlConnectedInsertFromSelectBuilder_1 = require("./MysqlConnectedInsertFromSelectBuilder.cjs");
+Object.defineProperty(exports, "MysqlConnectedInsertFromSelectBuilder", { enumerable: true, get: function () { return MysqlConnectedInsertFromSelectBuilder_1.MysqlConnectedInsertFromSelectBuilder; } });
+var MysqlConnectedSelectBuilder_1 = require("./MysqlConnectedSelectBuilder.cjs");
+Object.defineProperty(exports, "MysqlConnectedSelectBuilder", { enumerable: true, get: function () { return MysqlConnectedSelectBuilder_1.MysqlConnectedSelectBuilder; } });
+var MysqlConnectedQueryBuilder_1 = require("./MysqlConnectedQueryBuilder.cjs");
+Object.defineProperty(exports, "MysqlConnectedQueryBuilder", { enumerable: true, get: function () { return MysqlConnectedQueryBuilder_1.MysqlConnectedQueryBuilder; } });
+var MysqlPaginateBuilder_1 = require("./MysqlPaginateBuilder.cjs");
+Object.defineProperty(exports, "MysqlPaginateBuilder", { enumerable: true, get: function () { return MysqlPaginateBuilder_1.MysqlPaginateBuilder; } });
+var select_joins_1 = require("./select-joins.cjs");
+Object.defineProperty(exports, "executeMysqlTypeSafeJoin", { enumerable: true, get: function () { return select_joins_1.executeMysqlTypeSafeJoin; } });
+Object.defineProperty(exports, "executeMysqlCorrelatedSubqueryJoin", { enumerable: true, get: function () { return select_joins_1.executeMysqlCorrelatedSubqueryJoin; } });
+Object.defineProperty(exports, "executeMysqlJoinManyThrough", { enumerable: true, get: function () { return select_joins_1.executeMysqlJoinManyThrough; } });
+var select_pagination_1 = require("./select-pagination.cjs");
+Object.defineProperty(exports, "executeMysqlCursorEach", { enumerable: true, get: function () { return select_pagination_1.executeMysqlCursorEach; } });
+Object.defineProperty(exports, "executeMysqlPagination", { enumerable: true, get: function () { return select_pagination_1.executeMysqlPagination; } });
+var query_convenience_1 = require("./query-convenience.cjs");
+Object.defineProperty(exports, "executeMysqlFindById", { enumerable: true, get: function () { return query_convenience_1.executeMysqlFindById; } });
+Object.defineProperty(exports, "executeMysqlFindOne", { enumerable: true, get: function () { return query_convenience_1.executeMysqlFindOne; } });
+Object.defineProperty(exports, "executeMysqlFindMany", { enumerable: true, get: function () { return query_convenience_1.executeMysqlFindMany; } });
+Object.defineProperty(exports, "executeMysqlExists", { enumerable: true, get: function () { return query_convenience_1.executeMysqlExists; } });
+Object.defineProperty(exports, "executeMysqlUpsert", { enumerable: true, get: function () { return query_convenience_1.executeMysqlUpsert; } });
+Object.defineProperty(exports, "executeMysqlCreateWith", { enumerable: true, get: function () { return query_convenience_1.executeMysqlCreateWith; } });
+Object.defineProperty(exports, "executeMysqlSoftDelete", { enumerable: true, get: function () { return query_convenience_1.executeMysqlSoftDelete; } });
+Object.defineProperty(exports, "executeMysqlRestore", { enumerable: true, get: function () { return query_convenience_1.executeMysqlRestore; } });
+Object.defineProperty(exports, "getMysqlPrimaryKeyColumn", { enumerable: true, get: function () { return query_convenience_1.getMysqlPrimaryKeyColumn; } });