@relq/orm 0.1.3 → 0.1.5

package/dist/cjs/mysql/select/select-builder.cjs

@@ -0,0 +1,414 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlSelectBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+class MysqlSelectBuilder {
+    tableName;
+    tableAlias;
+    selectColumns = ['*'];
+    whereConditions = [];
+    havingConditions = [];
+    joinClauses = [];
+    structuredJoins = [];
+    groupByColumns = [];
+    orderByColumns = [];
+    limitValue;
+    offsetValue;
+    isDistinct = false;
+    lockingClause;
+    unionQueries = [];
+    includeExpressions = [];
+    columnResolver;
+    constructor(tableName, columns) {
+        this.tableName = tableName;
+        if (columns) {
+            this.selectColumns = Array.isArray(columns) ? columns : [columns];
+        }
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditionColumns(cond.values)
+                };
+            }
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.column.includes('.')) {
+                const [tableRef, colName] = cond.column.split('.');
+                return {
+                    ...cond,
+                    column: `${tableRef}.${this.columnResolver(colName)}`
+                };
+            }
+            return {
+                ...cond,
+                column: this.columnResolver(cond.column)
+            };
+        });
+    }
+    setTableAlias(alias) {
+        this.tableAlias = alias;
+        return this;
+    }
+    getTableIdentifier() {
+        return this.tableAlias || this.tableName;
+    }
+    distinct() {
+        this.isDistinct = true;
+        return this;
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof condition_collector_1.MysqlConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const conditionBuilder = new condition_collector_1.MysqlConditionCollector();
+            callbackOrCondition(conditionBuilder);
+            this.whereConditions.push(...conditionBuilder.getConditions());
+        }
+        return this;
+    }
+    join(table, condition) {
+        this.joinClauses.push(`JOIN ${mysql_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    leftJoin(table, condition) {
+        this.joinClauses.push(`LEFT JOIN ${mysql_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    rightJoin(table, condition) {
+        this.joinClauses.push(`RIGHT JOIN ${mysql_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    innerJoin(table, condition) {
+        this.joinClauses.push(`INNER JOIN ${mysql_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    crossJoin(table) {
+        this.joinClauses.push(`CROSS JOIN ${mysql_format_1.default.ident(table)}`);
+        return this;
+    }
+    lateralJoin(subquery, left = false) {
+        const joinType = left ? 'LEFT JOIN LATERAL' : 'JOIN LATERAL';
+        this.joinClauses.push(`${joinType} ${subquery}`);
+        return this;
+    }
+    addRawJoin(joinSQL) {
+        this.joinClauses.push(joinSQL);
+        return this;
+    }
+    groupBy(...columns) {
+        this.groupByColumns.push(...columns);
+        return this;
+    }
+    having(callback) {
+        const conditionBuilder = new condition_collector_1.MysqlConditionCollector();
+        callback(conditionBuilder);
+        this.havingConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByColumns.push({ column, direction });
+        return this;
+    }
+    orderAsc(column) {
+        return this.orderBy(column, 'ASC');
+    }
+    orderDesc(column) {
+        return this.orderBy(column, 'DESC');
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    forUpdate() {
+        this.lockingClause = 'FOR UPDATE';
+        return this;
+    }
+    forUpdateNoWait() {
+        this.lockingClause = 'FOR UPDATE NOWAIT';
+        return this;
+    }
+    forUpdateSkipLocked() {
+        this.lockingClause = 'FOR UPDATE SKIP LOCKED';
+        return this;
+    }
+    forShare() {
+        this.lockingClause = 'FOR SHARE';
+        return this;
+    }
+    forShareNoWait() {
+        this.lockingClause = 'FOR SHARE NOWAIT';
+        return this;
+    }
+    forShareSkipLocked() {
+        this.lockingClause = 'FOR SHARE SKIP LOCKED';
+        return this;
+    }
+    lockInShareMode() {
+        this.lockingClause = 'LOCK IN SHARE MODE';
+        return this;
+    }
+    union(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'UNION'
+        });
+        return this;
+    }
+    unionAll(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'UNION ALL'
+        });
+        return this;
+    }
+    intersect(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'INTERSECT'
+        });
+        return this;
+    }
+    except(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'EXCEPT'
+        });
+        return this;
+    }
+    addStructuredJoin(join) {
+        this.structuredJoins.push(join);
+        return this;
+    }
+    getStructuredJoins() {
+        return [...this.structuredJoins];
+    }
+    addIncludeExpression(alias, sql) {
+        this.includeExpressions.push({ alias, sql });
+        return this;
+    }
+    qualifyWhereConditions(conditions, tableRef) {
+        return conditions.map(cond => {
+            if (!cond.column)
+                return cond;
+            if (cond.column.includes('.'))
+                return cond;
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.qualifyWhereConditions(cond.values, tableRef)
+                };
+            }
+            return {
+                ...cond,
+                column: `${tableRef}.${cond.column}`
+            };
+        });
+    }
+    buildStructuredJoinSQL(join) {
+        if ((join.type === 'LEFT JOIN LATERAL' || join.type === 'JOIN LATERAL') && join.lateralSubquery) {
+            return `${join.type} ${join.lateralSubquery} ON true`;
+        }
+        if (join.type === 'CROSS JOIN') {
+            const tableRef = join.alias !== join.table
+                ? `${mysql_format_1.default.ident(join.table)} AS ${mysql_format_1.default.ident(join.alias)}`
+                : mysql_format_1.default.ident(join.table);
+            return `CROSS JOIN ${tableRef}`;
+        }
+        const tableRef = join.alias !== join.table
+            ? `${mysql_format_1.default.ident(join.table)} AS ${mysql_format_1.default.ident(join.alias)}`
+            : mysql_format_1.default.ident(join.table);
+        if (join.usingColumns && join.usingColumns.length > 0) {
+            const usingSQL = join.usingColumns.map(c => mysql_format_1.default.ident(c)).join(', ');
+            return `${join.type} ${tableRef} USING (${usingSQL})`;
+        }
+        if (join.onClause) {
+            return `${join.type} ${tableRef} ON ${join.onClause}`;
+        }
+        return `${join.type} ${tableRef}`;
+    }
+    toString() {
+        const hasJoins = this.joinClauses.length > 0 || this.structuredJoins.length > 0;
+        const tableRef = this.tableAlias || this.tableName;
+        const columns = this.selectColumns.map(col => {
+            if (col === '*') {
+                return hasJoins ? `${mysql_format_1.default.ident(tableRef)}.*` : '*';
+            }
+            if (Array.isArray(col)) {
+                const [column, alias] = col;
+                if (hasJoins) {
+                    return `${mysql_format_1.default.ident(tableRef)}.${mysql_format_1.default.ident(column)} AS ${mysql_format_1.default.ident(alias)}`;
+                }
+                return `${mysql_format_1.default.ident(column)} AS ${mysql_format_1.default.ident(alias)}`;
+            }
+            if (col.includes('(') || col.includes('DISTINCT') || col.includes(' AS ') || col.includes('.')) {
+                return col;
+            }
+            if (hasJoins) {
+                return `${mysql_format_1.default.ident(tableRef)}.${mysql_format_1.default.ident(col)}`;
+            }
+            return mysql_format_1.default.ident(col);
+        });
+        const hasGroupBy = this.groupByColumns.length > 0
+            || (this.includeExpressions.length > 0 && this.selectColumns.some(c => typeof c === 'string' && c !== '*'));
+        for (const join of this.structuredJoins) {
+            if (join.selectColumns && join.selectColumns.length > 0) {
+                const jsonArgs = join.selectColumns
+                    .map(col => `'${col.property}', ${mysql_format_1.default.ident(join.alias)}.${mysql_format_1.default.ident(col.sqlName)}`)
+                    .join(', ');
+                if (hasGroupBy) {
+                    columns.push(`COALESCE(JSON_ARRAYAGG(JSON_OBJECT(${jsonArgs})), JSON_ARRAY()) AS ${mysql_format_1.default.ident(join.alias)}`);
+                }
+                else {
+                    columns.push(`JSON_OBJECT(${jsonArgs}) AS ${mysql_format_1.default.ident(join.alias)}`);
+                }
+            }
+        }
+        for (const expr of this.includeExpressions) {
+            columns.push(`${expr.sql} AS ${mysql_format_1.default.ident(expr.alias)}`);
+        }
+        const columnsSQL = columns.join(', ');
+        let query = 'SELECT';
+        if (this.isDistinct) {
+            query += ' DISTINCT';
+        }
+        if (this.tableAlias && this.tableAlias !== this.tableName) {
+            query += ` ${columnsSQL} FROM ${mysql_format_1.default.ident(this.tableName)} AS ${mysql_format_1.default.ident(this.tableAlias)}`;
+        }
+        else {
+            query += ` ${columnsSQL} FROM ${mysql_format_1.default.ident(this.tableName)}`;
+        }
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.structuredJoins.length > 0) {
+            const structuredJoinSQL = this.structuredJoins
+                .map(join => this.buildStructuredJoinSQL(join))
+                .join(' ');
+            query += ' ' + structuredJoinSQL;
+        }
+        if (this.whereConditions.length > 0) {
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
+            query += ' WHERE ' + (0, condition_collector_1.buildMysqlConditionsSQL)(conditions);
+        }
+        let effectiveGroupBy = this.groupByColumns;
+        if (effectiveGroupBy.length === 0 && this.includeExpressions.length > 0) {
+            effectiveGroupBy = this.selectColumns
+                .filter(col => typeof col === 'string' && col !== '*')
+                .map(col => col);
+        }
+        if (effectiveGroupBy.length > 0) {
+            const groupBySQL = effectiveGroupBy.map(col => {
+                if (col.includes('.'))
+                    return col;
+                if (hasJoins)
+                    return `${mysql_format_1.default.ident(tableRef)}.${mysql_format_1.default.ident(col)}`;
+                return mysql_format_1.default.ident(col);
+            }).join(', ');
+            query += ' GROUP BY ' + groupBySQL;
+        }
+        if (this.havingConditions.length > 0) {
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
+            query += ' HAVING ' + (0, condition_collector_1.buildMysqlConditionsSQL)(havingConds);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(order => `${mysql_format_1.default.ident(order.column)} ${order.direction}`)
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += ` LIMIT ${this.limitValue}`;
+        }
+        if (this.offsetValue !== undefined) {
+            query += ` OFFSET ${this.offsetValue}`;
+        }
+        if (this.lockingClause) {
+            query += ' ' + this.lockingClause;
+        }
+        if (this.unionQueries.length > 0) {
+            for (const unionQuery of this.unionQueries) {
+                query += ` ${unionQuery.type} ${unionQuery.query}`;
+            }
+        }
+        return query;
+    }
+    whereRaw(condition) {
+        this.whereConditions.push({
+            method: 'raw',
+            column: condition,
+            values: undefined
+        });
+        return this;
+    }
+    toCountSQL() {
+        const hasJoins = this.joinClauses.length > 0 || this.structuredJoins.length > 0;
+        const tableRef = this.tableAlias || this.tableName;
+        let query;
+        if (this.tableAlias && this.tableAlias !== this.tableName) {
+            query = `SELECT COUNT(*) AS \`count\` FROM ${mysql_format_1.default.ident(this.tableName)} AS ${mysql_format_1.default.ident(this.tableAlias)}`;
+        }
+        else {
+            query = `SELECT COUNT(*) AS \`count\` FROM ${mysql_format_1.default.ident(this.tableName)}`;
+        }
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.structuredJoins.length > 0) {
+            const structuredJoinSQL = this.structuredJoins
+                .map(join => this.buildStructuredJoinSQL(join))
+                .join(' ');
+            query += ' ' + structuredJoinSQL;
+        }
+        if (this.whereConditions.length > 0) {
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
+            query += ' WHERE ' + (0, condition_collector_1.buildMysqlConditionsSQL)(conditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            const groupBySQL = this.groupByColumns.map(col => {
+                if (col.includes('.'))
+                    return col;
+                if (hasJoins)
+                    return `${mysql_format_1.default.ident(tableRef)}.${mysql_format_1.default.ident(col)}`;
+                return mysql_format_1.default.ident(col);
+            }).join(', ');
+            query += ' GROUP BY ' + groupBySQL;
+        }
+        if (this.havingConditions.length > 0) {
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
+            query += ' HAVING ' + (0, condition_collector_1.buildMysqlConditionsSQL)(havingConds);
+        }
+        return query;
+    }
+}
+exports.MysqlSelectBuilder = MysqlSelectBuilder;

package/dist/cjs/mysql/select/sql-expression.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlAggregateFunctions = exports.MysqlSqlExpression = void 0;
+const table_proxy_1 = require("./table-proxy.cjs");
+class MysqlSqlExpression {
+    sql;
+    _isSqlExpression = true;
+    constructor(sql) {
+        this.sql = sql;
+    }
+}
+exports.MysqlSqlExpression = MysqlSqlExpression;
+class MysqlAggregateFunctions {
+    count(ref) {
+        if (!ref)
+            return new MysqlSqlExpression('COALESCE(CAST(COUNT(*) AS SIGNED), 0)');
+        return new MysqlSqlExpression(`COALESCE(CAST(COUNT(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}) AS SIGNED), 0)`);
+    }
+    countDistinct(ref) {
+        return new MysqlSqlExpression(`COALESCE(CAST(COUNT(DISTINCT ${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}) AS SIGNED), 0)`);
+    }
+    sum(ref) {
+        return new MysqlSqlExpression(`COALESCE(CAST(SUM(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}) AS DOUBLE), 0)`);
+    }
+    avg(ref) {
+        return new MysqlSqlExpression(`CAST(AVG(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}) AS DOUBLE)`);
+    }
+    min(ref) {
+        return new MysqlSqlExpression(`MIN(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)})`);
+    }
+    max(ref) {
+        return new MysqlSqlExpression(`MAX(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)})`);
+    }
+    stringAgg(ref, delimiter = ', ') {
+        return new MysqlSqlExpression(`COALESCE(GROUP_CONCAT(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)} SEPARATOR '${delimiter}'), '')`);
+    }
+    arrayAgg(ref) {
+        return new MysqlSqlExpression(`COALESCE(JSON_ARRAYAGG(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}), JSON_ARRAY())`);
+    }
+    arrayAggDistinct(ref) {
+        return new MysqlSqlExpression(`COALESCE(JSON_ARRAYAGG(DISTINCT ${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}), JSON_ARRAY())`);
+    }
+    boolAnd(ref) {
+        return new MysqlSqlExpression(`CAST(COALESCE(MIN(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}), 0) AS SIGNED)`);
+    }
+    boolOr(ref) {
+        return new MysqlSqlExpression(`CAST(COALESCE(MAX(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}), 0) AS SIGNED)`);
+    }
+    stddev(ref) {
+        return new MysqlSqlExpression(`CAST(STDDEV(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}) AS DOUBLE)`);
+    }
+    variance(ref) {
+        return new MysqlSqlExpression(`CAST(VARIANCE(${(0, table_proxy_1.mysqlColumnRefToSQL)(ref)}) AS DOUBLE)`);
+    }
+}
+exports.MysqlAggregateFunctions = MysqlAggregateFunctions;

package/dist/cjs/mysql/select/table-proxy.cjs

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMysqlColumnRef = isMysqlColumnRef;
+exports.createMysqlTableProxy = createMysqlTableProxy;
+exports.createMysqlJoinCallbackParams = createMysqlJoinCallbackParams;
+exports.mysqlColumnRefToSQL = mysqlColumnRefToSQL;
+exports.mysqlColumnRefToSQLUnqualified = mysqlColumnRefToSQLUnqualified;
+exports.mysqlColumnRefsEqual = mysqlColumnRefsEqual;
+function isMysqlColumnRef(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '$table' in value &&
+        '$alias' in value &&
+        '$column' in value &&
+        '$sqlColumn' in value);
+}
+function createMysqlTableProxy(tableName, alias, tableSchema) {
+    return new Proxy({}, {
+        get(_, prop) {
+            if (typeof prop === 'symbol') {
+                return undefined;
+            }
+            const columns = tableSchema?.$columns || tableSchema;
+            const columnDef = columns?.[prop];
+            let sqlColumn;
+            if (columnDef) {
+                sqlColumn = columnDef.$sqlName || columnDef.$name || columnDef.$columnName || camelToSnake(prop);
+            }
+            else {
+                sqlColumn = camelToSnake(prop);
+            }
+            return {
+                $table: tableName,
+                $alias: alias,
+                $column: prop,
+                $sqlColumn: sqlColumn,
+                $type: undefined
+            };
+        },
+        has(_, prop) {
+            if (typeof prop === 'symbol')
+                return false;
+            const columns = tableSchema?.$columns || tableSchema;
+            return columns ? prop in columns : true;
+        },
+        ownKeys(_) {
+            const columns = tableSchema?.$columns || tableSchema;
+            return columns ? Object.keys(columns) : [];
+        },
+        getOwnPropertyDescriptor(_, prop) {
+            if (typeof prop === 'symbol')
+                return undefined;
+            const columns = tableSchema?.$columns || tableSchema;
+            if (columns && prop in columns) {
+                const columnDef = columns[prop];
+                const sqlColumn = columnDef?.$sqlName || columnDef?.$name || columnDef?.$columnName || camelToSnake(prop);
+                return {
+                    enumerable: true,
+                    configurable: true,
+                    value: {
+                        $table: tableName,
+                        $alias: alias,
+                        $column: prop,
+                        $sqlColumn: sqlColumn,
+                        $type: undefined
+                    }
+                };
+            }
+            return undefined;
+        }
+    });
+}
+function createMysqlJoinCallbackParams(leftTableKey, leftAlias, leftTableDef, rightTableKey, rightAlias, rightTableDef) {
+    const leftTableName = leftTableDef?.$name || leftTableKey;
+    const rightTableName = rightTableDef?.$name || rightTableKey;
+    return {
+        leftProxy: createMysqlTableProxy(leftTableName, leftAlias, leftTableDef),
+        rightProxy: createMysqlTableProxy(rightTableName, rightAlias, rightTableDef),
+        leftTableName,
+        rightTableName
+    };
+}
+function camelToSnake(str) {
+    return str
+        .replace(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .replace(/^_/, '');
+}
+function mysqlColumnRefToSQL(ref) {
+    return `\`${ref.$alias}\`.\`${ref.$sqlColumn}\``;
+}
+function mysqlColumnRefToSQLUnqualified(ref) {
+    return `\`${ref.$sqlColumn}\``;
+}
+function mysqlColumnRefsEqual(a, b) {
+    return a.$table === b.$table &&
+        a.$alias === b.$alias &&
+        a.$sqlColumn === b.$sqlColumn;
+}

package/dist/cjs/mysql/shared/mysql-table-accessor.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMysqlTableAccessor = createMysqlTableAccessor;
+const MysqlConnectedQueryBuilder_1 = require("../helpers/MysqlConnectedQueryBuilder.cjs");
+function createMysqlTableAccessor(relq, schema) {
+    const tableFunction = (tableName) => {
+        return new MysqlConnectedQueryBuilder_1.MysqlConnectedQueryBuilder(tableName, relq);
+    };
+    return new Proxy(tableFunction, {
+        get(target, prop, receiver) {
+            if (prop in target) {
+                return Reflect.get(target, prop, receiver);
+            }
+            if (typeof prop === 'string' && schema && prop in schema) {
+                const tableDef = schema[prop];
+                const sqlTableName = tableDef?.$name || prop;
+                return new MysqlConnectedQueryBuilder_1.MysqlConnectedQueryBuilder(sqlTableName, relq, prop);
+            }
+            return undefined;
+        }
+    });
+}

package/dist/cjs/mysql/transaction/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlSavepointBuilder = exports.MysqlTransactionBuilder = void 0;
+var transaction_builder_1 = require("./transaction-builder.cjs");
+Object.defineProperty(exports, "MysqlTransactionBuilder", { enumerable: true, get: function () { return transaction_builder_1.MysqlTransactionBuilder; } });
+Object.defineProperty(exports, "MysqlSavepointBuilder", { enumerable: true, get: function () { return transaction_builder_1.MysqlSavepointBuilder; } });

package/dist/cjs/mysql/transaction/transaction-builder.cjs

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlSavepointBuilder = exports.MysqlTransactionBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+class MysqlTransactionBuilder {
+    isolationLevel;
+    mode;
+    isolation(level) {
+        this.isolationLevel = level;
+        return this;
+    }
+    readWrite() {
+        this.mode = 'READ WRITE';
+        return this;
+    }
+    readOnly() {
+        this.mode = 'READ ONLY';
+        return this;
+    }
+    begin() {
+        const statements = [];
+        if (this.isolationLevel) {
+            statements.push(`SET TRANSACTION ISOLATION LEVEL ${this.isolationLevel}`);
+        }
+        let startTxn = 'START TRANSACTION';
+        if (this.mode) {
+            startTxn += ` ${this.mode}`;
+        }
+        statements.push(startTxn);
+        return statements.join('; ');
+    }
+    commit() {
+        return 'COMMIT';
+    }
+    rollback() {
+        return 'ROLLBACK';
+    }
+    toString() {
+        return this.begin();
+    }
+}
+exports.MysqlTransactionBuilder = MysqlTransactionBuilder;
+class MysqlSavepointBuilder {
+    savepointName;
+    constructor(savepointName) {
+        this.savepointName = savepointName;
+    }
+    create() {
+        return `SAVEPOINT ${mysql_format_1.default.ident(this.savepointName)}`;
+    }
+    rollback() {
+        return `ROLLBACK TO SAVEPOINT ${mysql_format_1.default.ident(this.savepointName)}`;
+    }
+    release() {
+        return `RELEASE SAVEPOINT ${mysql_format_1.default.ident(this.savepointName)}`;
+    }
+    toString() {
+        return this.create();
+    }
+}
+exports.MysqlSavepointBuilder = MysqlSavepointBuilder;