@relq/orm 0.1.3 → 0.1.5

package/dist/cjs/mysql/update/column-expression-builder.cjs

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlColumnExpressionBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+class MysqlColumnExpressionBuilder {
+    increment(amount = 1) {
+        return `COALESCE(__COLUMN__, 0) + ${mysql_format_1.default.literal(amount)}`;
+    }
+    decrement(amount = 1) {
+        return `COALESCE(__COLUMN__, 0) - ${mysql_format_1.default.literal(amount)}`;
+    }
+    multiply(factor) {
+        return `COALESCE(__COLUMN__, 0) * ${mysql_format_1.default.literal(factor)}`;
+    }
+    toggle() {
+        return `NOT COALESCE(__COLUMN__, false)`;
+    }
+    concat(suffix) {
+        return `CONCAT(COALESCE(__COLUMN__, ''), ${mysql_format_1.default.literal(suffix)})`;
+    }
+    prepend(prefix) {
+        return `CONCAT(${mysql_format_1.default.literal(prefix)}, COALESCE(__COLUMN__, ''))`;
+    }
+    replace(search, replacement) {
+        return `REPLACE(COALESCE(__COLUMN__, ''), ${mysql_format_1.default.literal(search)}, ${mysql_format_1.default.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})`;
+    }
+}
+exports.MysqlColumnExpressionBuilder = MysqlColumnExpressionBuilder;

package/dist/cjs/mysql/update/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlJsonUpdateBuilder = exports.MysqlUpdateBuilder = void 0;
+var update_builder_1 = require("./update-builder.cjs");
+Object.defineProperty(exports, "MysqlUpdateBuilder", { enumerable: true, get: function () { return update_builder_1.MysqlUpdateBuilder; } });
+var mysql_json_update_builder_1 = require("./mysql-json-update-builder.cjs");
+Object.defineProperty(exports, "MysqlJsonUpdateBuilder", { enumerable: true, get: function () { return mysql_json_update_builder_1.MysqlJsonUpdateBuilder; } });

package/dist/cjs/mysql/update/mysql-json-update-builder.cjs

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlJsonUpdateBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+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 = mysql_format_1.default.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 ? mysql_format_1.default.literal(op.path) : '';
+        const col = mysql_format_1.default.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 => mysql_format_1.default.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 = mysql_format_1.default.literal(arrPath);
+                    return `JSON_REMOVE(${current}, CONCAT(${pathLit}, '[', JSON_LENGTH(JSON_EXTRACT(${col}, ${pathLit})) - ${offset}, ']'))`;
+                }
+                return current;
+            }
+            default:
+                return current;
+        }
+    }
+}
+exports.MysqlJsonUpdateBuilder = MysqlJsonUpdateBuilder;
+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 mysql_format_1.default.literal(value);
+}

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

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlUpdateBuilder = void 0;
+const mysql_format_1 = __importDefault(require("../clients/shared/mysql-format.cjs"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const mysql_json_update_builder_1 = require("./mysql-json-update-builder.cjs");
+const column_expression_builder_1 = require("./column-expression-builder.cjs");
+const case_converter_1 = require("../../utils/case-converter.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+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 (0, case_converter_1.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 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;
+    }
+    innerJoin(table, condition) {
+        this.joinClauses.push(`INNER JOIN ${mysql_format_1.default.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 mysql_json_update_builder_1.MysqlJsonUpdateBuilder(resolvedCol);
+                const opsBuilder = {
+                    json: jsonBuilder,
+                    col: new column_expression_builder_1.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, mysql_format_1.default.ident(resolvedCol));
+                setClauses.push(`${mysql_format_1.default.ident(resolvedCol)} = ${finalExpr}`);
+            }
+            else if (value instanceof mysql_json_update_builder_1.MysqlJsonUpdateBuilder) {
+                setClauses.push(`${mysql_format_1.default.ident(resolvedCol)} = ${value.toSQL()}`);
+            }
+            else if (value === null || value === undefined) {
+                setClauses.push(`${mysql_format_1.default.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(`${mysql_format_1.default.ident(resolvedCol)} = CAST('${json}' AS JSON)`);
+            }
+            else {
+                setClauses.push(`${mysql_format_1.default.ident(resolvedCol)} = ${mysql_format_1.default.literal(value)}`);
+            }
+        }
+        if (setClauses.length === 0) {
+            throw new relq_errors_1.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 ${mysql_format_1.default.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 ' + (0, condition_collector_1.buildMysqlConditionsSQL)(transformedConditions);
+        }
+        if (this.joinClauses.length === 0) {
+            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}`;
+            }
+        }
+        return query;
+    }
+}
+exports.MysqlUpdateBuilder = MysqlUpdateBuilder;

package/dist/cjs/mysql/utils/addon/mysql/mysql2.cjs

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+__exportStar(require("../../../../addon/mysql2.cjs"), exports);
+var promise_1 = require("../../../../addon/mysql2.cjs");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(promise_1).default; } });

package/dist/cjs/mysql/utils/fk-resolver.cjs

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlForeignKeyResolutionError = void 0;
+exports.resolveMysqlForeignKey = resolveMysqlForeignKey;
+exports.resolveMysqlForeignKeyOrThrow = resolveMysqlForeignKeyOrThrow;
+exports.getAvailableMysqlRelations = getAvailableMysqlRelations;
+exports.getAllMysqlForeignKeys = getAllMysqlForeignKeys;
+class MysqlForeignKeyResolutionError extends Error {
+    fromTable;
+    toTable;
+    constructor(fromTable, toTable, message) {
+        super(message || `No foreign key relationship found between "${fromTable}" and "${toTable}"`);
+        this.fromTable = fromTable;
+        this.toTable = toTable;
+        this.name = 'MysqlForeignKeyResolutionError';
+    }
+}
+exports.MysqlForeignKeyResolutionError = MysqlForeignKeyResolutionError;
+function resolveMysqlForeignKey(schema, fromTableKey, toTableKey) {
+    const fromTableDef = schema[fromTableKey];
+    const toTableDef = schema[toTableKey];
+    if (!fromTableDef || !toTableDef) {
+        return null;
+    }
+    const fromTableName = fromTableDef.$name;
+    const toTableName = toTableDef.$name;
+    if (fromTableDef.$foreignKeys) {
+        for (const fk of fromTableDef.$foreignKeys) {
+            if (fk.references.table === toTableName || fk.references.table === toTableKey) {
+                if (fk.columns.length > 0 && fk.references.columns.length > 0) {
+                    return {
+                        fromTable: fromTableName,
+                        fromColumn: resolveColumnName(fromTableDef, fk.columns[0]),
+                        toTable: toTableName,
+                        toColumn: resolveColumnName(toTableDef, fk.references.columns[0]),
+                        direction: 'forward',
+                    };
+                }
+            }
+        }
+    }
+    if (toTableDef.$foreignKeys) {
+        const candidates = [];
+        for (const fk of toTableDef.$foreignKeys) {
+            if (fk.references.table === fromTableName || fk.references.table === fromTableKey) {
+                if (fk.columns.length > 0 && fk.references.columns.length > 0) {
+                    candidates.push(fk);
+                }
+            }
+        }
+        if (candidates.length > 0) {
+            let best = candidates[0];
+            if (candidates.length > 1) {
+                let bestScore = 0;
+                const columns = toTableDef.$columns || {};
+                for (const candidate of candidates) {
+                    const colName = candidate.columns[0];
+                    for (const [propKey, colDef] of Object.entries(columns)) {
+                        if (!colDef)
+                            continue;
+                        const sqlName = colDef.$columnName || colDef.$sqlName;
+                        if (sqlName !== colName && propKey !== colName)
+                            continue;
+                        let score = 0;
+                        if (colDef.$primaryKey === true)
+                            score = 2;
+                        else if (colDef.$nullable === false || colDef.$notNull === true)
+                            score = 1;
+                        if (score > bestScore) {
+                            bestScore = score;
+                            best = candidate;
+                        }
+                        break;
+                    }
+                }
+            }
+            return {
+                fromTable: fromTableName,
+                fromColumn: resolveColumnName(fromTableDef, best.references.columns[0]),
+                toTable: toTableName,
+                toColumn: resolveColumnName(toTableDef, best.columns[0]),
+                direction: 'reverse',
+            };
+        }
+    }
+    for (const [_key, tableDef] of Object.entries(schema)) {
+        if (tableDef === fromTableDef || tableDef === toTableDef)
+            continue;
+        if (!tableDef.$foreignKeys)
+            continue;
+        for (const fk of tableDef.$foreignKeys) {
+            if (fk.references.table === fromTableName || fk.references.table === fromTableKey) {
+                const otherFk = tableDef.$foreignKeys.find(f => f !== fk && (f.references.table === toTableName || f.references.table === toTableKey));
+                if (otherFk) {
+                    continue;
+                }
+            }
+        }
+    }
+    return null;
+}
+function resolveMysqlForeignKeyOrThrow(schema, fromTableKey, toTableKey) {
+    const result = resolveMysqlForeignKey(schema, fromTableKey, toTableKey);
+    if (!result) {
+        const available = getAvailableMysqlRelations(schema, fromTableKey);
+        let message = `No foreign key relationship found between "${fromTableKey}" and "${toTableKey}".`;
+        if (available.length > 0) {
+            message += ` Available FK relations from "${fromTableKey}": ${available.join(', ')}.`;
+        }
+        else {
+            message += ` No foreign keys defined on "${fromTableKey}".`;
+        }
+        message += ' Use an explicit join condition instead.';
+        throw new MysqlForeignKeyResolutionError(fromTableKey, toTableKey, message);
+    }
+    return result;
+}
+function getAvailableMysqlRelations(schema, tableKey) {
+    const tableDef = schema[tableKey];
+    if (!tableDef || !tableDef.$foreignKeys) {
+        return [];
+    }
+    return tableDef.$foreignKeys.map(fk => {
+        const cols = fk.columns.join(', ');
+        const refCols = fk.references.columns.join(', ');
+        return `(${cols}) → ${fk.references.table}(${refCols})`;
+    });
+}
+function getAllMysqlForeignKeys(schema, tableKey) {
+    const tableDef = schema[tableKey];
+    if (!tableDef) {
+        return [];
+    }
+    const tableName = tableDef.$name;
+    const results = [];
+    if (tableDef.$foreignKeys) {
+        for (const fk of tableDef.$foreignKeys) {
+            const targetKey = findTableKeyByName(schema, fk.references.table);
+            const targetDef = targetKey ? schema[targetKey] : null;
+            if (fk.columns.length > 0 && fk.references.columns.length > 0) {
+                results.push({
+                    fromTable: tableName,
+                    fromColumn: resolveColumnName(tableDef, fk.columns[0]),
+                    toTable: fk.references.table,
+                    toColumn: targetDef
+                        ? resolveColumnName(targetDef, fk.references.columns[0])
+                        : fk.references.columns[0],
+                    direction: 'forward',
+                });
+            }
+        }
+    }
+    for (const [otherKey, otherDef] of Object.entries(schema)) {
+        if (otherKey === tableKey)
+            continue;
+        if (!otherDef.$foreignKeys)
+            continue;
+        for (const fk of otherDef.$foreignKeys) {
+            if (fk.references.table === tableName || fk.references.table === tableKey) {
+                if (fk.columns.length > 0 && fk.references.columns.length > 0) {
+                    results.push({
+                        fromTable: tableName,
+                        fromColumn: resolveColumnName(tableDef, fk.references.columns[0]),
+                        toTable: otherDef.$name,
+                        toColumn: resolveColumnName(otherDef, fk.columns[0]),
+                        direction: 'reverse',
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+function resolveColumnName(tableDef, columnKey) {
+    if (tableDef.$columns && tableDef.$columns[columnKey]) {
+        return tableDef.$columns[columnKey].$columnName || columnKey;
+    }
+    return columnKey;
+}
+function findTableKeyByName(schema, tableName) {
+    for (const [key, def] of Object.entries(schema)) {
+        if (def.$name === tableName || key === tableName) {
+            return key;
+        }
+    }
+    return null;
+}

package/dist/cjs/mysql/utils/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMysqlSchemaColumns = exports.serializeMysqlRow = exports.deserializeMysqlRows = exports.deserializeMysqlRow = exports.serializeMysqlValue = exports.deserializeMysqlValue = exports.MysqlForeignKeyResolutionError = exports.getAllMysqlForeignKeys = exports.getAvailableMysqlRelations = exports.resolveMysqlForeignKeyOrThrow = exports.resolveMysqlForeignKey = void 0;
+var fk_resolver_1 = require("./fk-resolver.cjs");
+Object.defineProperty(exports, "resolveMysqlForeignKey", { enumerable: true, get: function () { return fk_resolver_1.resolveMysqlForeignKey; } });
+Object.defineProperty(exports, "resolveMysqlForeignKeyOrThrow", { enumerable: true, get: function () { return fk_resolver_1.resolveMysqlForeignKeyOrThrow; } });
+Object.defineProperty(exports, "getAvailableMysqlRelations", { enumerable: true, get: function () { return fk_resolver_1.getAvailableMysqlRelations; } });
+Object.defineProperty(exports, "getAllMysqlForeignKeys", { enumerable: true, get: function () { return fk_resolver_1.getAllMysqlForeignKeys; } });
+Object.defineProperty(exports, "MysqlForeignKeyResolutionError", { enumerable: true, get: function () { return fk_resolver_1.MysqlForeignKeyResolutionError; } });
+var type_coercion_1 = require("./type-coercion.cjs");
+Object.defineProperty(exports, "deserializeMysqlValue", { enumerable: true, get: function () { return type_coercion_1.deserializeMysqlValue; } });
+Object.defineProperty(exports, "serializeMysqlValue", { enumerable: true, get: function () { return type_coercion_1.serializeMysqlValue; } });
+Object.defineProperty(exports, "deserializeMysqlRow", { enumerable: true, get: function () { return type_coercion_1.deserializeMysqlRow; } });
+Object.defineProperty(exports, "deserializeMysqlRows", { enumerable: true, get: function () { return type_coercion_1.deserializeMysqlRows; } });
+Object.defineProperty(exports, "serializeMysqlRow", { enumerable: true, get: function () { return type_coercion_1.serializeMysqlRow; } });
+Object.defineProperty(exports, "extractMysqlSchemaColumns", { enumerable: true, get: function () { return type_coercion_1.extractMysqlSchemaColumns; } });