@relq/orm 0.1.3 → 0.1.4

package/dist/esm/mysql/index.js

@@ -0,0 +1,47 @@
+export { MysqlConditionCollector, buildMysqlConditionSQL, buildMysqlConditionsSQL, MysqlJsonConditionCollector, buildMysqlJsonConditionSQL, MysqlFulltextConditionCollector, buildMysqlFulltextConditionSQL } from "./condition/index.js";
+export { MysqlSelectBuilder } from "./select/index.js";
+export { MYSQL_JOIN_INTERNAL, MYSQL_JOIN_SETUP } from "./select/index.js";
+export { createMysqlTableProxy, createMysqlJoinCallbackParams, mysqlColumnRefToSQL, mysqlColumnRefToSQLUnqualified, mysqlColumnRefsEqual, isMysqlColumnRef } from "./select/index.js";
+export { MysqlAggregateFunctions } from "./select/index.js";
+export { MysqlJoinConditionBuilder, createMysqlJoinConditionBuilder } from "./select/index.js";
+export { MysqlJoinManyBuilder, createMysqlJoinManyBuilder } from "./select/index.js";
+export { MysqlAggregateQueryBuilder } from "./select/index.js";
+export { MysqlScalarQueryBuilderImpl, createMysqlScalarTableAccessor } from "./select/index.js";
+export { MysqlScalarSelectBuilder, MysqlConnectedScalarSelectBuilder } from "./select/index.js";
+export { MysqlInsertBuilder, MysqlInsertFromSelectBuilder } from "./insert/index.js";
+export { MysqlDuplicateKeyBuilder, buildDuplicateKeyUpdateSql, createValuesProxy, createMysqlRowProxy, createMysqlSqlHelpers } from "./insert/index.js";
+export { MysqlUpdateBuilder, MysqlJsonUpdateBuilder } from "./update/index.js";
+export { MysqlDeleteBuilder } from "./delete/index.js";
+export { MysqlCountBuilder } from "./count/index.js";
+export { MysqlExplainBuilder } from "./explain/index.js";
+export { MysqlRawQueryBuilder } from "./raw/index.js";
+export { mysqlSql, MysqlSqlFragment } from "./raw/index.js";
+export { MysqlTransactionBuilder, MysqlSavepointBuilder } from "./transaction/index.js";
+export { MysqlWindowBuilder } from "./window/index.js";
+export { default as mysqlFormat, mysqlIdent, mysqlLiteral } from "./clients/shared/mysql-format.js";
+export { MysqlConnectedRawQueryBuilder } from "./helpers/index.js";
+export { MysqlConnectedCountBuilder } from "./helpers/index.js";
+export { MysqlTransactionClient, executeMysqlTransaction } from "./helpers/index.js";
+export { MysqlConnectedDeleteBuilder } from "./helpers/index.js";
+export { MysqlConnectedUpdateBuilder } from "./helpers/index.js";
+export { MysqlConnectedInsertBuilder } from "./helpers/index.js";
+export { MysqlConnectedAggregateBuilder } from "./helpers/index.js";
+export { NativeCTEBuilder } from "./helpers/index.js";
+export { MysqlConnectedInsertFromSelectBuilder } from "./helpers/index.js";
+export { MysqlConnectedSelectBuilder } from "./helpers/index.js";
+export { MysqlConnectedQueryBuilder } from "./helpers/index.js";
+export { MysqlPaginateBuilder } from "./helpers/index.js";
+export { executeMysqlTypeSafeJoin, executeMysqlCorrelatedSubqueryJoin, executeMysqlJoinManyThrough } from "./helpers/index.js";
+export { executeMysqlCursorEach, executeMysqlPagination } from "./helpers/index.js";
+export { executeMysqlFindById, executeMysqlFindOne, executeMysqlFindMany, executeMysqlExists, executeMysqlUpsert, executeMysqlCreateWith, executeMysqlSoftDelete, executeMysqlRestore, getMysqlPrimaryKeyColumn } from "./helpers/index.js";
+export { MysqlReturningExecutor } from "./helpers/MysqlReturningExecutor.js";
+export { RelqMysql, MYSQL_CAPABILITIES } from "./clients/index.js";
+export { RelqMariaDB, MARIADB_CAPABILITIES } from "./clients/index.js";
+export { RelqPlanetScale, PLANETSCALE_CAPABILITIES } from "./clients/index.js";
+export { MysqlBase } from "./clients/index.js";
+export { mysqlDialect } from "./clients/shared/mysql-dialect.js";
+export { getMysqlDialectCapabilities } from "./clients/shared/mysql-dialect.js";
+export { isMysqlConnectionError, isMysqlTransientError, isMysqlPoolRecoverableError, parseMysqlError } from "./clients/shared/mysql-error-parser.js";
+export { mysqlTypeCoercion } from "./clients/shared/mysql-type-coercion.js";
+export { resolveMysqlForeignKey, resolveMysqlForeignKeyOrThrow, getAvailableMysqlRelations, getAllMysqlForeignKeys, MysqlForeignKeyResolutionError } from "./utils/index.js";
+export { deserializeMysqlValue, serializeMysqlValue, deserializeMysqlRow, deserializeMysqlRows, serializeMysqlRow, extractMysqlSchemaColumns } from "./utils/index.js";

package/dist/esm/mysql/insert/duplicate-key-builder.js

@@ -0,0 +1,174 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+function isColumnRef(value) {
+    return typeof value === 'object' && value !== null && value.__type === 'column_ref';
+}
+function isSqlExpression(value) {
+    return typeof value === 'object' && value !== null && value.__type === 'sql_expression';
+}
+export function createValuesProxy() {
+    return new Proxy({}, {
+        get(_target, prop) {
+            return { __type: 'column_ref', table: 'VALUES', column: prop };
+        }
+    });
+}
+export function createMysqlRowProxy(tableName) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            return { __type: 'column_ref', table: tableName, column: prop };
+        }
+    });
+}
+function columnRefToSql(ref, columnResolver) {
+    const resolvedCol = columnResolver ? columnResolver(ref.column) : ref.column;
+    if (ref.table === 'VALUES') {
+        return `VALUES(${mysqlFormat.ident(resolvedCol)})`;
+    }
+    return `${mysqlFormat.ident(ref.table)}.${mysqlFormat.ident(resolvedCol)}`;
+}
+function valueToSql(value, columnResolver) {
+    if (isColumnRef(value)) {
+        return columnRefToSql(value, columnResolver);
+    }
+    if (isSqlExpression(value)) {
+        return value.sql;
+    }
+    if (typeof value === 'number' || typeof value === 'bigint') {
+        return String(value);
+    }
+    return mysqlFormat.literal(value);
+}
+export function createMysqlSqlHelpers(currentColumn, tableName, columnResolver) {
+    const resolve = (col) => columnResolver ? columnResolver(col) : col;
+    const resolvedColumn = resolve(currentColumn);
+    const expr = (sql) => ({ __type: 'sql_expression', sql });
+    return {
+        increment(amount) {
+            return expr(`${mysqlFormat.ident(tableName)}.${mysqlFormat.ident(resolvedColumn)} + ${amount}`);
+        },
+        add(a, b) {
+            return expr(`${valueToSql(a, columnResolver)} + ${valueToSql(b, columnResolver)}`);
+        },
+        subtract(a, b) {
+            return expr(`${valueToSql(a, columnResolver)} - ${valueToSql(b, columnResolver)}`);
+        },
+        multiply(a, b) {
+            return expr(`${valueToSql(a, columnResolver)} * ${valueToSql(b, columnResolver)}`);
+        },
+        divide(a, b) {
+            return expr(`${valueToSql(a, columnResolver)} / ${valueToSql(b, columnResolver)}`);
+        },
+        modulo(a, b) {
+            return expr(`MOD(${valueToSql(a, columnResolver)}, ${valueToSql(b, columnResolver)})`);
+        },
+        abs(value) {
+            return expr(`ABS(${valueToSql(value, columnResolver)})`);
+        },
+        ceil(value) {
+            return expr(`CEIL(${valueToSql(value, columnResolver)})`);
+        },
+        floor(value) {
+            return expr(`FLOOR(${valueToSql(value, columnResolver)})`);
+        },
+        round(value, decimals) {
+            if (decimals !== undefined) {
+                return expr(`ROUND(${valueToSql(value, columnResolver)}, ${decimals})`);
+            }
+            return expr(`ROUND(${valueToSql(value, columnResolver)})`);
+        },
+        coalesce(...values) {
+            return expr(`COALESCE(${values.map(v => valueToSql(v, columnResolver)).join(', ')})`);
+        },
+        greatest(...values) {
+            return expr(`GREATEST(${values.map(v => valueToSql(v, columnResolver)).join(', ')})`);
+        },
+        least(...values) {
+            return expr(`LEAST(${values.map(v => valueToSql(v, columnResolver)).join(', ')})`);
+        },
+        ifnull(a, b) {
+            return expr(`IFNULL(${valueToSql(a, columnResolver)}, ${valueToSql(b, columnResolver)})`);
+        },
+        concat(...values) {
+            return expr(`CONCAT(${values.map(v => valueToSql(v, columnResolver)).join(', ')})`);
+        },
+        lower(value) {
+            return expr(`LOWER(${valueToSql(value, columnResolver)})`);
+        },
+        upper(value) {
+            return expr(`UPPER(${valueToSql(value, columnResolver)})`);
+        },
+        trim(value) {
+            return expr(`TRIM(${valueToSql(value, columnResolver)})`);
+        },
+        now() {
+            return expr('NOW()');
+        },
+        currentTimestamp() {
+            return expr('CURRENT_TIMESTAMP');
+        }
+    };
+}
+export class MysqlDuplicateKeyBuilder {
+    _updateData = {};
+    _tableName;
+    _columnResolver;
+    constructor(tableName) {
+        this._tableName = tableName;
+    }
+    setColumnResolver(resolver) {
+        this._columnResolver = resolver;
+        return this;
+    }
+    doUpdate(data) {
+        const valuesProxy = createValuesProxy();
+        const rowProxy = createMysqlRowProxy(this._tableName);
+        for (const [column, value] of Object.entries(data)) {
+            if (typeof value === 'function') {
+                const fn = value;
+                const sqlHelpers = createMysqlSqlHelpers(column, this._tableName, this._columnResolver);
+                let result;
+                if (fn.length === 1) {
+                    result = fn(valuesProxy);
+                }
+                else if (fn.length === 2) {
+                    result = fn(valuesProxy, sqlHelpers);
+                }
+                else {
+                    result = fn(valuesProxy, sqlHelpers, rowProxy);
+                }
+                this._updateData[column] = result;
+            }
+            else {
+                this._updateData[column] = value;
+            }
+        }
+        return this;
+    }
+    get updateData() {
+        return this._updateData;
+    }
+    get tableName() {
+        return this._tableName;
+    }
+}
+export function buildDuplicateKeyUpdateSql(updateData, _tableName, columnResolver) {
+    const resolve = (col) => columnResolver ? columnResolver(col) : col;
+    const setClauses = [];
+    for (const [column, value] of Object.entries(updateData)) {
+        const resolvedCol = resolve(column);
+        if (isColumnRef(value)) {
+            setClauses.push(`${mysqlFormat.ident(resolvedCol)} = ${columnRefToSql(value, columnResolver)}`);
+        }
+        else if (isSqlExpression(value)) {
+            setClauses.push(`${mysqlFormat.ident(resolvedCol)} = ${value.sql}`);
+        }
+        else if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+            const json = JSON.stringify(value).replace(/'/g, "''");
+            setClauses.push(`${mysqlFormat.ident(resolvedCol)} = CAST('${json}' AS JSON)`);
+        }
+        else {
+            setClauses.push(`${mysqlFormat.ident(resolvedCol)} = ${mysqlFormat.literal(value)}`);
+        }
+    }
+    return setClauses.join(', ');
+}

package/dist/esm/mysql/insert/index.js

@@ -0,0 +1,3 @@
+export { MysqlInsertBuilder } from "./insert-builder.js";
+export { MysqlInsertFromSelectBuilder } from "./insert-from-select-builder.js";
+export { MysqlDuplicateKeyBuilder, buildDuplicateKeyUpdateSql, createValuesProxy, createMysqlRowProxy, createMysqlSqlHelpers } from "./duplicate-key-builder.js";

package/dist/esm/mysql/insert/insert-builder.js

@@ -0,0 +1,162 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { convertCase } from "../../utils/case-converter.js";
+import { MysqlDuplicateKeyBuilder, buildDuplicateKeyUpdateSql } from "./duplicate-key-builder.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+export class MysqlInsertBuilder {
+    tableName;
+    insertData;
+    insertMode = 'INSERT';
+    duplicateKeyBuilder;
+    _case = 'keep-case';
+    _convertCase = '2snake';
+    originalColumns;
+    columnResolver;
+    constructor(tableName, data) {
+        this.tableName = tableName;
+        const normalized = this.normalizeData(data);
+        this.insertData = [normalized];
+        this.originalColumns = Object.keys(normalized).sort();
+    }
+    normalizeData(data) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(data)) {
+            normalized[key] = value === undefined ? null : value;
+        }
+        return normalized;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return this.convertColumnName(name);
+    }
+    convertCase(type, conversionCase = '2snake') {
+        this._case = type;
+        this._convertCase = conversionCase;
+        return this;
+    }
+    validateColumns(row) {
+        const newColumns = Object.keys(row).sort();
+        if (newColumns.length !== this.originalColumns.length) {
+            throw new RelqBuilderError(`Column count mismatch: expected ${this.originalColumns.length} columns, got ${newColumns.length}`, { builder: 'MysqlInsertBuilder', hint: `Expected columns: [${this.originalColumns.join(', ')}]` });
+        }
+        for (let i = 0; i < this.originalColumns.length; i++) {
+            if (this.originalColumns[i] !== newColumns[i]) {
+                throw new RelqBuilderError('Column name mismatch: all rows must have the exact same column names', { builder: 'MysqlInsertBuilder', hint: `Expected columns: [${this.originalColumns.join(', ')}]` });
+            }
+        }
+    }
+    addRow(row) {
+        const normalized = this.normalizeData(row);
+        if (this.insertData.length === 0) {
+            this.originalColumns = Object.keys(normalized).sort();
+        }
+        else {
+            this.validateColumns(normalized);
+        }
+        this.insertData.push(normalized);
+        return this;
+    }
+    addRows(rows) {
+        if (rows.length === 0)
+            return this;
+        const normalizedRows = rows.map(row => this.normalizeData(row));
+        if (this.insertData.length === 0) {
+            this.originalColumns = Object.keys(normalizedRows[0]).sort();
+        }
+        if (normalizedRows.length > 0) {
+            this.validateColumns(normalizedRows[0]);
+            if (normalizedRows.length > 1) {
+                this.validateColumns(normalizedRows[normalizedRows.length - 1]);
+            }
+        }
+        this.insertData.push(...normalizedRows);
+        return this;
+    }
+    clear() {
+        this.insertData = [];
+        this.originalColumns = [];
+        return this;
+    }
+    get total() {
+        return this.insertData.length;
+    }
+    ignore() {
+        this.insertMode = 'INSERT IGNORE';
+        return this;
+    }
+    replace() {
+        this.insertMode = 'REPLACE';
+        return this;
+    }
+    onDuplicateKeyUpdate(callback) {
+        this.duplicateKeyBuilder = new MysqlDuplicateKeyBuilder(this.tableName);
+        if (this.columnResolver) {
+            this.duplicateKeyBuilder.setColumnResolver(this.columnResolver);
+        }
+        callback(this.duplicateKeyBuilder);
+        return this;
+    }
+    convertColumnName(name) {
+        if (this._case === 'to-lower')
+            return name.toLowerCase();
+        if (this._case === 'to-upper')
+            return name.toUpperCase();
+        if (this._case === 'convert-case')
+            return convertCase(name, this._convertCase);
+        return name;
+    }
+    formatMysqlValue(value) {
+        if (value === null || value === undefined) {
+            return { formatted: 'NULL', isRaw: true };
+        }
+        if (Array.isArray(value) || (typeof value === 'object' && !(value instanceof Date))) {
+            const json = JSON.stringify(value).replace(/'/g, "''").replace(/\\/g, '\\\\');
+            return { formatted: `CAST('${json}' AS JSON)`, isRaw: true };
+        }
+        return { formatted: mysqlFormat.literal(value), isRaw: true };
+    }
+    buildDuplicateKeyClause() {
+        if (!this.duplicateKeyBuilder)
+            return '';
+        const updateSql = buildDuplicateKeyUpdateSql(this.duplicateKeyBuilder.updateData, this.tableName, (col) => this.resolveColumnName(col));
+        return ` ON DUPLICATE KEY UPDATE ${updateSql}`;
+    }
+    toString() {
+        if (this.insertData.length === 0) {
+            throw new RelqBuilderError('Cannot generate INSERT query: no rows to insert', { builder: 'MysqlInsertBuilder', missing: 'data', hint: 'Add rows using addRow() or addRows() first' });
+        }
+        const originalColumns = Object.keys(this.insertData[0]);
+        const columns = originalColumns.map(name => this.resolveColumnName(name));
+        const columnsSQL = columns.map(c => mysqlFormat.ident(c)).join(', ');
+        const allValuesGroups = [];
+        for (const row of this.insertData) {
+            const vals = [];
+            for (const colName of originalColumns) {
+                const { formatted } = this.formatMysqlValue(row[colName]);
+                vals.push(formatted);
+            }
+            allValuesGroups.push(`(${vals.join(', ')})`);
+        }
+        let keyword;
+        switch (this.insertMode) {
+            case 'INSERT IGNORE':
+                keyword = 'INSERT IGNORE INTO';
+                break;
+            case 'REPLACE':
+                keyword = 'REPLACE INTO';
+                break;
+            default:
+                keyword = 'INSERT INTO';
+        }
+        let query = `${keyword} ${mysqlFormat.ident(this.tableName)} (${columnsSQL}) VALUES ${allValuesGroups.join(', ')}`;
+        if (this.insertMode === 'INSERT' && this.duplicateKeyBuilder) {
+            query += this.buildDuplicateKeyClause();
+        }
+        return query;
+    }
+}

package/dist/esm/mysql/insert/insert-from-select-builder.js

@@ -0,0 +1,67 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { MysqlDuplicateKeyBuilder, buildDuplicateKeyUpdateSql, } from "./duplicate-key-builder.js";
+export class MysqlInsertFromSelectBuilder {
+    tableName;
+    columns;
+    selectSQL;
+    insertMode = 'INSERT';
+    duplicateKeyBuilder;
+    columnResolver;
+    constructor(tableName, columns, selectSQL) {
+        this.tableName = tableName;
+        this.columns = columns;
+        this.selectSQL = selectSQL;
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    ignore() {
+        this.insertMode = 'INSERT IGNORE';
+        return this;
+    }
+    replace() {
+        this.insertMode = 'REPLACE';
+        return this;
+    }
+    onDuplicateKeyUpdate(callback) {
+        this.duplicateKeyBuilder = new MysqlDuplicateKeyBuilder(this.tableName);
+        if (this.columnResolver) {
+            this.duplicateKeyBuilder.setColumnResolver(this.columnResolver);
+        }
+        callback(this.duplicateKeyBuilder);
+        return this;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return name;
+    }
+    buildDuplicateKeyClause() {
+        if (!this.duplicateKeyBuilder)
+            return '';
+        const updateSql = buildDuplicateKeyUpdateSql(this.duplicateKeyBuilder.updateData, this.tableName, (col) => this.resolveColumnName(col));
+        return ` ON DUPLICATE KEY UPDATE ${updateSql}`;
+    }
+    toString() {
+        const resolvedColumns = this.columns.map(c => this.resolveColumnName(c));
+        const columnsSQL = resolvedColumns.map(c => mysqlFormat.ident(c)).join(', ');
+        let keyword;
+        switch (this.insertMode) {
+            case 'INSERT IGNORE':
+                keyword = 'INSERT IGNORE INTO';
+                break;
+            case 'REPLACE':
+                keyword = 'REPLACE INTO';
+                break;
+            default:
+                keyword = 'INSERT INTO';
+        }
+        let query = `${keyword} ${mysqlFormat.ident(this.tableName)} (${columnsSQL}) ${this.selectSQL}`;
+        if (this.insertMode === 'INSERT' && this.duplicateKeyBuilder) {
+            query += this.buildDuplicateKeyClause();
+        }
+        return query;
+    }
+}

package/dist/esm/mysql/raw/index.js

@@ -0,0 +1,2 @@
+export { MysqlRawQueryBuilder } from "./raw-query-builder.js";
+export { mysqlSql, MysqlSqlFragment } from "./sql-template.js";

package/dist/esm/mysql/raw/raw-query-builder.js

@@ -0,0 +1,20 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { RelqQueryError } from "../../shared/errors/relq-errors.js";
+export class MysqlRawQueryBuilder {
+    query;
+    params;
+    constructor(query, params = []) {
+        this.query = query;
+        this.params = params;
+    }
+    toString() {
+        if (!this.query || typeof this.query !== 'string' || this.query.trim() === '') {
+            throw new RelqQueryError(`Invalid query provided: ${this.query === null ? 'null' : this.query === undefined ? 'undefined' : 'empty string'}`, { hint: 'Provide a valid SQL query string' });
+        }
+        const result = this.params.length > 0 ? mysqlFormat(this.query, ...this.params) : this.query;
+        if (!result || typeof result !== 'string') {
+            throw new RelqQueryError(`mysqlFormat() returned invalid result: ${result === null ? 'null' : result === undefined ? 'undefined' : typeof result}`, { sql: this.query });
+        }
+        return result;
+    }
+}

package/dist/esm/mysql/raw/sql-template.js

@@ -0,0 +1,58 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+export class MysqlSqlFragment {
+    text;
+    _isSqlFragment = true;
+    constructor(text) {
+        this.text = text;
+    }
+    toString() {
+        return this.text;
+    }
+}
+function sqlIdentifier(name) {
+    return new MysqlSqlFragment(mysqlFormat.ident(name));
+}
+function mysqlSql(strings, ...values) {
+    let result = '';
+    for (let i = 0; i < strings.length; i++) {
+        result += strings[i];
+        if (i < values.length) {
+            result += formatValue(values[i]);
+        }
+    }
+    return new MysqlSqlFragment(result);
+}
+function formatValue(value) {
+    if (value && value._isSqlFragment === true) {
+        return value.text;
+    }
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    if (value instanceof Date) {
+        return mysqlFormat.literal(value.toISOString());
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return "CAST('[]' AS JSON)";
+        }
+        const escaped = value.map(v => formatValue(v)).join(', ');
+        return `(${escaped})`;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (typeof value === 'number' || typeof value === 'bigint') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return mysqlFormat.literal(value);
+    }
+    if (typeof value === 'object') {
+        const json = JSON.stringify(value).replace(/'/g, "''").replace(/\\/g, '\\\\');
+        return `CAST('${json}' AS JSON)`;
+    }
+    return mysqlFormat.literal(String(value));
+}
+mysqlSql.id = sqlIdentifier;
+export { mysqlSql };