@relq/orm 0.1.3 → 0.1.4

package/dist/esm/mysql/select/table-proxy.js

@@ -0,0 +1,91 @@
+export function isMysqlColumnRef(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '$table' in value &&
+        '$alias' in value &&
+        '$column' in value &&
+        '$sqlColumn' in value);
+}
+export 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;
+        }
+    });
+}
+export 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(/^_/, '');
+}
+export function mysqlColumnRefToSQL(ref) {
+    return `\`${ref.$alias}\`.\`${ref.$sqlColumn}\``;
+}
+export function mysqlColumnRefToSQLUnqualified(ref) {
+    return `\`${ref.$sqlColumn}\``;
+}
+export function mysqlColumnRefsEqual(a, b) {
+    return a.$table === b.$table &&
+        a.$alias === b.$alias &&
+        a.$sqlColumn === b.$sqlColumn;
+}

package/dist/esm/mysql/shared/mysql-table-accessor.js

@@ -0,0 +1,19 @@
+import { MysqlConnectedQueryBuilder } from "../helpers/MysqlConnectedQueryBuilder.js";
+export function createMysqlTableAccessor(relq, schema) {
+    const tableFunction = (tableName) => {
+        return new 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(sqlTableName, relq, prop);
+            }
+            return undefined;
+        }
+    });
+}

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

@@ -0,0 +1 @@
+export { MysqlTransactionBuilder, MysqlSavepointBuilder } from "./transaction-builder.js";

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

@@ -0,0 +1,56 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+export 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();
+    }
+}
+export class MysqlSavepointBuilder {
+    savepointName;
+    constructor(savepointName) {
+        this.savepointName = savepointName;
+    }
+    create() {
+        return `SAVEPOINT ${mysqlFormat.ident(this.savepointName)}`;
+    }
+    rollback() {
+        return `ROLLBACK TO SAVEPOINT ${mysqlFormat.ident(this.savepointName)}`;
+    }
+    release() {
+        return `RELEASE SAVEPOINT ${mysqlFormat.ident(this.savepointName)}`;
+    }
+    toString() {
+        return this.create();
+    }
+}

package/dist/esm/mysql/update/column-expression-builder.js

@@ -0,0 +1,42 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+export class MysqlColumnExpressionBuilder {
+    increment(amount = 1) {
+        return `COALESCE(__COLUMN__, 0) + ${mysqlFormat.literal(amount)}`;
+    }
+    decrement(amount = 1) {
+        return `COALESCE(__COLUMN__, 0) - ${mysqlFormat.literal(amount)}`;
+    }
+    multiply(factor) {
+        return `COALESCE(__COLUMN__, 0) * ${mysqlFormat.literal(factor)}`;
+    }
+    toggle() {
+        return `NOT COALESCE(__COLUMN__, false)`;
+    }
+    concat(suffix) {
+        return `CONCAT(COALESCE(__COLUMN__, ''), ${mysqlFormat.literal(suffix)})`;
+    }
+    prepend(prefix) {
+        return `CONCAT(${mysqlFormat.literal(prefix)}, COALESCE(__COLUMN__, ''))`;
+    }
+    replace(search, replacement) {
+        return `REPLACE(COALESCE(__COLUMN__, ''), ${mysqlFormat.literal(search)}, ${mysqlFormat.literal(replacement)})`;
+    }
+    lower() {
+        return `LOWER(__COLUMN__)`;
+    }
+    upper() {
+        return `UPPER(__COLUMN__)`;
+    }
+    trim() {
+        return `TRIM(__COLUMN__)`;
+    }
+    now() {
+        return `NOW()`;
+    }
+    addInterval(value, unit) {
+        return `DATE_ADD(COALESCE(__COLUMN__, NOW()), INTERVAL ${value} ${unit})`;
+    }
+    subtractInterval(value, unit) {
+        return `DATE_SUB(COALESCE(__COLUMN__, NOW()), INTERVAL ${value} ${unit})`;
+    }
+}

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

@@ -0,0 +1,2 @@
+export { MysqlUpdateBuilder } from "./update-builder.js";
+export { MysqlJsonUpdateBuilder } from "./mysql-json-update-builder.js";

package/dist/esm/mysql/update/mysql-json-update-builder.js

@@ -0,0 +1,193 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+export class MysqlJsonUpdateBuilder {
+    updates = [];
+    columnName;
+    constructor(columnName) {
+        this.columnName = columnName;
+    }
+    set(path, value) {
+        this.updates.push({ type: 'set', path, value });
+        return this;
+    }
+    setDeep(path, value) {
+        return this.set(path, value);
+    }
+    setMany(pairs) {
+        for (const [path, value] of Object.entries(pairs)) {
+            this.updates.push({ type: 'set', path, value });
+        }
+        return this;
+    }
+    insert(path, value) {
+        this.updates.push({ type: 'insert', path, value });
+        return this;
+    }
+    replace(path, value) {
+        this.updates.push({ type: 'replace', path, value });
+        return this;
+    }
+    remove(path) {
+        this.updates.push({ type: 'remove', path });
+        return this;
+    }
+    removeMany(paths) {
+        if (paths.length === 0)
+            return this;
+        this.updates.push({ type: 'raw', meta: { fn: 'JSON_REMOVE', paths } });
+        return this;
+    }
+    merge(value) {
+        this.updates.push({ type: 'merge_patch', value });
+        return this;
+    }
+    mergeDeep(value) {
+        this.updates.push({ type: 'merge_preserve', value });
+        return this;
+    }
+    increment(path, amount = 1) {
+        this.updates.push({ type: 'increment', path, value: amount });
+        return this;
+    }
+    decrement(path, amount = 1) {
+        this.updates.push({ type: 'decrement', path, value: amount });
+        return this;
+    }
+    toggle(path) {
+        this.updates.push({ type: 'toggle', path });
+        return this;
+    }
+    arrayAppend(path, value) {
+        this.updates.push({ type: 'array_append', path, value });
+        return this;
+    }
+    arrayInsert(path, value) {
+        this.updates.push({ type: 'array_insert', path, value });
+        return this;
+    }
+    setIf(path, value, condition) {
+        this.updates.push({ type: 'set_if', path, value, meta: { condition } });
+        return this;
+    }
+    setDefault(path, value) {
+        return this.insert(path, value);
+    }
+    deleteKey(parentPath, key) {
+        const fullPath = parentPath === '$' ? `$.${key}` : `${parentPath}.${key}`;
+        this.updates.push({ type: 'remove', path: fullPath });
+        return this;
+    }
+    removeAt(path, index) {
+        if (index >= 0) {
+            const fullPath = `${path}[${index}]`;
+            this.updates.push({ type: 'remove', path: fullPath });
+        }
+        else {
+            const absOffset = Math.abs(index);
+            this.updates.push({
+                type: 'raw',
+                meta: {
+                    fn: 'JSON_REMOVE_AT_NEGATIVE',
+                    path,
+                    offset: absOffset,
+                },
+            });
+        }
+        return this;
+    }
+    shift(path = '$') {
+        return this.removeAt(path, 0);
+    }
+    pop(path = '$') {
+        return this.removeAt(path, -1);
+    }
+    toSQL() {
+        const col = mysqlFormat.ident(this.columnName);
+        let expr = col;
+        for (const op of this.updates) {
+            expr = this.applyOp(expr, op);
+        }
+        return expr;
+    }
+    applyOp(current, op) {
+        const pathLiteral = op.path ? mysqlFormat.literal(op.path) : '';
+        const col = mysqlFormat.ident(this.columnName);
+        switch (op.type) {
+            case 'set': {
+                const val = formatJsonValue(op.value);
+                return `JSON_SET(${current}, ${pathLiteral}, ${val})`;
+            }
+            case 'insert': {
+                const val = formatJsonValue(op.value);
+                return `JSON_INSERT(${current}, ${pathLiteral}, ${val})`;
+            }
+            case 'replace': {
+                const val = formatJsonValue(op.value);
+                return `JSON_REPLACE(${current}, ${pathLiteral}, ${val})`;
+            }
+            case 'remove':
+                return `JSON_REMOVE(${current}, ${pathLiteral})`;
+            case 'array_append': {
+                const val = formatJsonValue(op.value);
+                return `JSON_ARRAY_APPEND(${current}, ${pathLiteral}, ${val})`;
+            }
+            case 'array_insert': {
+                const val = formatJsonValue(op.value);
+                return `JSON_ARRAY_INSERT(${current}, ${pathLiteral}, ${val})`;
+            }
+            case 'merge_patch': {
+                const val = formatJsonValue(op.value);
+                return `JSON_MERGE_PATCH(${current}, ${val})`;
+            }
+            case 'merge_preserve': {
+                const val = formatJsonValue(op.value);
+                return `JSON_MERGE_PRESERVE(${current}, ${val})`;
+            }
+            case 'increment': {
+                const amount = op.value;
+                return `JSON_SET(${current}, ${pathLiteral}, COALESCE(JSON_EXTRACT(${col}, ${pathLiteral}), 0) + ${amount})`;
+            }
+            case 'decrement': {
+                const amount = op.value;
+                return `JSON_SET(${current}, ${pathLiteral}, COALESCE(JSON_EXTRACT(${col}, ${pathLiteral}), 0) - ${amount})`;
+            }
+            case 'toggle': {
+                return `JSON_SET(${current}, ${pathLiteral}, NOT COALESCE(JSON_EXTRACT(${col}, ${pathLiteral}), FALSE))`;
+            }
+            case 'set_if': {
+                const val = formatJsonValue(op.value);
+                const condition = op.meta?.condition;
+                return `CASE WHEN ${condition} THEN JSON_SET(${current}, ${pathLiteral}, ${val}) ELSE ${col} END`;
+            }
+            case 'raw': {
+                const fn = op.meta?.fn;
+                if (fn === 'JSON_REMOVE') {
+                    const paths = op.meta?.paths;
+                    const pathArgs = paths.map(p => mysqlFormat.literal(p)).join(', ');
+                    return `JSON_REMOVE(${current}, ${pathArgs})`;
+                }
+                if (fn === 'JSON_REMOVE_AT_NEGATIVE') {
+                    const arrPath = op.meta?.path;
+                    const offset = op.meta?.offset;
+                    const pathLit = mysqlFormat.literal(arrPath);
+                    return `JSON_REMOVE(${current}, CONCAT(${pathLit}, '[', JSON_LENGTH(JSON_EXTRACT(${col}, ${pathLit})) - ${offset}, ']'))`;
+                }
+                return current;
+            }
+            default:
+                return current;
+        }
+    }
+}
+function formatJsonValue(value) {
+    if (value === null || value === undefined)
+        return 'NULL';
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (typeof value === 'number')
+        return String(value);
+    if (typeof value === 'object') {
+        const json = JSON.stringify(value).replace(/'/g, "''").replace(/\\/g, '\\\\');
+        return `CAST('${json}' AS JSON)`;
+    }
+    return mysqlFormat.literal(value);
+}

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

@@ -0,0 +1,160 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+import { MysqlConditionCollector, buildMysqlConditionsSQL } from "../condition/condition-collector.js";
+import { MysqlJsonUpdateBuilder } from "./mysql-json-update-builder.js";
+import { MysqlColumnExpressionBuilder } from "./column-expression-builder.js";
+import { convertCase } from "../../utils/case-converter.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+export class MysqlUpdateBuilder {
+    tableName;
+    updateData = {};
+    whereConditions = [];
+    joinClauses = [];
+    orderByColumns = [];
+    limitValue;
+    columnResolver;
+    _case = 'keep-case';
+    _convertCase = '2snake';
+    constructor(tableName, data) {
+        this.tableName = tableName;
+        if (data) {
+            this.updateData = { ...data };
+        }
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    convertCase(type, conversionCase = '2snake') {
+        this._case = type;
+        this._convertCase = conversionCase;
+        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;
+    }
+    resolveColumnName(name) {
+        if (this.columnResolver) {
+            return this.columnResolver(name);
+        }
+        return this.convertColumnName(name);
+    }
+    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) };
+        });
+    }
+    set(data) {
+        Object.assign(this.updateData, data);
+        return this;
+    }
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof MysqlConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const conditionBuilder = new MysqlConditionCollector();
+            callbackOrCondition(conditionBuilder);
+            this.whereConditions.push(...conditionBuilder.getConditions());
+        }
+        return this;
+    }
+    join(table, condition) {
+        this.joinClauses.push(`JOIN ${mysqlFormat.ident(table)} ON ${condition}`);
+        return this;
+    }
+    leftJoin(table, condition) {
+        this.joinClauses.push(`LEFT JOIN ${mysqlFormat.ident(table)} ON ${condition}`);
+        return this;
+    }
+    innerJoin(table, condition) {
+        this.joinClauses.push(`INNER JOIN ${mysqlFormat.ident(table)} ON ${condition}`);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByColumns.push({ column, direction });
+        return this;
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    toString() {
+        const setClauses = [];
+        for (const [column, value] of Object.entries(this.updateData)) {
+            const resolvedCol = this.resolveColumnName(column);
+            if (typeof value === 'function') {
+                const jsonBuilder = new MysqlJsonUpdateBuilder(resolvedCol);
+                const opsBuilder = {
+                    json: jsonBuilder,
+                    col: new MysqlColumnExpressionBuilder()
+                };
+                const result = value(opsBuilder);
+                let sqlExpr;
+                if (typeof result === 'string') {
+                    sqlExpr = result;
+                }
+                else if (result && typeof result.toSQL === 'function') {
+                    sqlExpr = result.toSQL();
+                }
+                else {
+                    sqlExpr = jsonBuilder.toSQL();
+                }
+                const finalExpr = sqlExpr.replace(/__COLUMN__/g, mysqlFormat.ident(resolvedCol));
+                setClauses.push(`${mysqlFormat.ident(resolvedCol)} = ${finalExpr}`);
+            }
+            else if (value instanceof MysqlJsonUpdateBuilder) {
+                setClauses.push(`${mysqlFormat.ident(resolvedCol)} = ${value.toSQL()}`);
+            }
+            else if (value === null || value === undefined) {
+                setClauses.push(`${mysqlFormat.ident(resolvedCol)} = NULL`);
+            }
+            else if (Array.isArray(value) || (typeof value === 'object' && !(value instanceof Date))) {
+                const json = JSON.stringify(value).replace(/'/g, "''").replace(/\\/g, '\\\\');
+                setClauses.push(`${mysqlFormat.ident(resolvedCol)} = CAST('${json}' AS JSON)`);
+            }
+            else {
+                setClauses.push(`${mysqlFormat.ident(resolvedCol)} = ${mysqlFormat.literal(value)}`);
+            }
+        }
+        if (setClauses.length === 0) {
+            throw new RelqBuilderError('Cannot generate UPDATE query: no columns to update', { builder: 'MysqlUpdateBuilder', missing: 'data', hint: 'Pass data to update() or use set() to add columns' });
+        }
+        let query = `UPDATE ${mysqlFormat.ident(this.tableName)}`;
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        query += ` SET ${setClauses.join(', ')}`;
+        if (this.whereConditions.length > 0) {
+            const transformedConditions = this.transformConditionColumns(this.whereConditions);
+            query += ' WHERE ' + buildMysqlConditionsSQL(transformedConditions);
+        }
+        if (this.joinClauses.length === 0) {
+            if (this.orderByColumns.length > 0) {
+                query += ' ORDER BY ' + this.orderByColumns
+                    .map(order => `${mysqlFormat.ident(order.column)} ${order.direction}`)
+                    .join(', ');
+            }
+            if (this.limitValue !== undefined) {
+                query += ` LIMIT ${this.limitValue}`;
+            }
+        }
+        return query;
+    }
+}

package/dist/esm/mysql/utils/addon/mysql/mysql2.js

@@ -0,0 +1,2 @@
+export * from "../../../../addon/mysql2.js";
+export { default } from "../../../../addon/mysql2.js";