relq 1.0.5 → 1.0.6

package/dist/esm/cli/utils/ast/codegen/builder.js

@@ -0,0 +1,291 @@
+import { toCamelCase, escapeString } from "./utils.js";
+export const KNOWN_BUILDER_FUNCTIONS = {
+    'setweight': 'setweight',
+    'to_tsvector': 'toTsvector',
+    'to_tsquery': 'toTsquery',
+    'plainto_tsquery': 'plainToTsquery',
+    'phraseto_tsquery': 'phraseToTsquery',
+    'websearch_to_tsquery': 'websearchToTsquery',
+    'ts_headline': 'tsHeadline',
+    'ts_rank': 'tsRank',
+    'ts_rank_cd': 'tsRankCd',
+    'coalesce': 'coalesce',
+    'nullif': 'nullif',
+    'greatest': 'greatest',
+    'least': 'least',
+    'concat': 'concat',
+    'concat_ws': 'concatWs',
+    'lower': 'lower',
+    'upper': 'upper',
+    'trim': 'trim',
+    'ltrim': 'ltrim',
+    'rtrim': 'rtrim',
+    'length': 'length',
+    'substring': 'substring',
+    'replace': 'replace',
+    'regexp_replace': 'regexpReplace',
+    'split_part': 'splitPart',
+    'now': 'now',
+    'current_timestamp': 'currentTimestamp',
+    'current_date': 'currentDate',
+    'current_time': 'currentTime',
+    'date_trunc': 'dateTrunc',
+    'date_part': 'datePart',
+    'extract': 'extract',
+    'age': 'age',
+    'gen_random_uuid': 'genRandomUuid',
+    'uuid_generate_v4': 'uuidGenerateV4',
+    'jsonb_build_object': 'jsonbBuildObject',
+    'jsonb_agg': 'jsonbAgg',
+    'json_agg': 'jsonAgg',
+    'array_agg': 'arrayAgg',
+    'string_agg': 'stringAgg',
+    'count': 'count',
+    'sum': 'sum',
+    'avg': 'avg',
+    'min': 'min',
+    'max': 'max',
+    'abs': 'abs',
+    'ceil': 'ceil',
+    'floor': 'floor',
+    'round': 'round',
+    'sqrt': 'sqrt',
+    'power': 'power',
+    'mod': 'mod',
+    'random': 'random',
+};
+export function mapFunctionToBuilder(funcName) {
+    return KNOWN_BUILDER_FUNCTIONS[funcName] || null;
+}
+export function astToBuilder(node, prefixOrOptions = 'g') {
+    const opts = typeof prefixOrOptions === 'string'
+        ? { prefix: prefixOrOptions }
+        : prefixOrOptions;
+    const { prefix = 'g', useCamelCase = false, useTableRef = false } = opts;
+    if (!node)
+        return "''";
+    if (node.FuncCall) {
+        const func = node.FuncCall;
+        const funcName = func.funcname?.map((n) => n.String?.sval).filter(Boolean).join('.') || '';
+        const args = (func.args || []).map((a) => astToBuilder(a, opts));
+        const builderMethod = mapFunctionToBuilder(funcName.toLowerCase());
+        if (builderMethod) {
+            return `${prefix}.${builderMethod}(${args.join(', ')})`;
+        }
+        throw new Error(`Unsupported function in generated expression: "${funcName}". Add this function to KNOWN_BUILDER_FUNCTIONS in astToBuilder.`);
+    }
+    if (node.CoalesceExpr) {
+        const args = (node.CoalesceExpr.args || []).map((a) => astToBuilder(a, opts));
+        return `${prefix}.coalesce(${args.join(', ')})`;
+    }
+    if (node.A_Expr) {
+        const expr = node.A_Expr;
+        const op = expr.name?.[0]?.String?.sval || '';
+        const left = astToBuilder(expr.lexpr, opts);
+        const right = astToBuilder(expr.rexpr, opts);
+        switch (op) {
+            case '||':
+                return `__CONCAT__[${left}, ${right}]`;
+            case '->>':
+                return `${prefix}.jsonbExtractText(${left}, ${right})`;
+            case '->':
+                return `${prefix}.jsonbExtract(${left}, ${right})`;
+            case '@@':
+                return `${prefix}.tsMatch(${left}, ${right})`;
+            case '+':
+                return `${prefix}.add(${left}, ${right})`;
+            case '-':
+                return `${prefix}.subtract(${left}, ${right})`;
+            case '*':
+                return `${prefix}.multiply(${left}, ${right})`;
+            case '/':
+                return `${prefix}.divide(${left}, ${right})`;
+            case '%':
+                return `${prefix}.mod(${left}, ${right})`;
+            case '=':
+            case '<>':
+            case '!=':
+            case '<':
+            case '>':
+            case '<=':
+            case '>=':
+                if (useTableRef) {
+                    const methodMap = {
+                        '=': 'eq', '<>': 'ne', '!=': 'neq',
+                        '<': 'lt', '>': 'gt', '<=': 'lte', '>=': 'gte'
+                    };
+                    return `${left}.${methodMap[op]}(${right})`;
+                }
+                return `${prefix}.compare(${left}, '${op}', ${right})`;
+            case '~':
+            case '~*':
+            case '!~':
+            case '!~*':
+                return `${prefix}.regex(${left}, '${op}', ${right})`;
+            default:
+                throw new Error(`Unsupported operator in generated expression: "${op}". Add explicit handling for this operator in astToBuilder.`);
+        }
+    }
+    if (node.ColumnRef) {
+        const fields = (node.ColumnRef.fields || [])
+            .map((f) => f.String?.sval)
+            .filter(Boolean);
+        if (fields.length === 1) {
+            const colName = useCamelCase ? toCamelCase(fields[0]) : fields[0];
+            return `table.${colName}`;
+        }
+        else if (fields.length === 2) {
+            const colName = useCamelCase ? toCamelCase(fields[1]) : fields[1];
+            return `table.${colName}`;
+        }
+        const colName = useCamelCase ? toCamelCase(fields[fields.length - 1]) : fields[fields.length - 1];
+        return `table.${colName}`;
+    }
+    if (node.A_Const) {
+        const val = node.A_Const;
+        if (val.sval !== undefined) {
+            const s = val.sval?.sval ?? val.sval;
+            if (s === '' || s === ' ') {
+                return s === '' ? `${prefix}.asText()` : `${prefix}.asText(' ')`;
+            }
+            return `'${escapeString(String(s))}'`;
+        }
+        else if (val.ival !== undefined) {
+            const i = val.ival?.ival ?? val.ival;
+            return String(i);
+        }
+        else if (val.fval !== undefined) {
+            const f = val.fval?.fval ?? val.fval;
+            return String(f);
+        }
+        else if (val.boolval !== undefined) {
+            return val.boolval?.boolval ? 'true' : 'false';
+        }
+        return `${prefix}.asText()`;
+    }
+    if (node.TypeCast) {
+        const arg = astToBuilder(node.TypeCast.arg, opts);
+        const typeName = node.TypeCast.typeName?.names
+            ?.map((n) => n.String?.sval)
+            .filter(Boolean)
+            .join('.') || '';
+        if (typeName === 'regconfig' || typeName === 'pg_catalog.regconfig') {
+            return arg;
+        }
+        if (typeName === 'text' || typeName === 'pg_catalog.text') {
+            return `${prefix}.asText(${arg})`;
+        }
+        if (typeName === 'varchar' || typeName === 'pg_catalog.varchar' || typeName.includes('character varying')) {
+            return arg;
+        }
+        if (typeName === 'char' || typeName === 'bpchar' || typeName === 'pg_catalog.bpchar') {
+            return arg;
+        }
+        if (typeName === 'numeric' || typeName === 'pg_catalog.numeric') {
+            return arg;
+        }
+        if (typeName === 'int4' || typeName === 'integer' || typeName === 'pg_catalog.int4') {
+            return arg;
+        }
+        return `${prefix}.cast(${arg}, '${typeName}')`;
+    }
+    if (node.NullTest) {
+        const arg = astToBuilder(node.NullTest.arg, opts);
+        const isNull = node.NullTest.nulltesttype === 'IS_NULL';
+        return isNull ? `${prefix}.isNull(${arg})` : `${prefix}.isNotNull(${arg})`;
+    }
+    if (node.BoolExpr) {
+        const boolexpr = node.BoolExpr;
+        const args = (boolexpr.args || []).map((a) => astToBuilder(a, opts));
+        if (useTableRef && args.length >= 2) {
+            switch (boolexpr.boolop) {
+                case 'AND_EXPR': return args.reduce((acc, arg) => `${acc}.and(${arg})`);
+                case 'OR_EXPR': return args.reduce((acc, arg) => `${acc}.or(${arg})`);
+                case 'NOT_EXPR': return `${args[0]}.not()`;
+            }
+        }
+        switch (boolexpr.boolop) {
+            case 'AND_EXPR': return `${prefix}.and(${args.join(', ')})`;
+            case 'OR_EXPR': return `${prefix}.or(${args.join(', ')})`;
+            case 'NOT_EXPR': return `${prefix}.not(${args[0]})`;
+        }
+    }
+    if (node.CaseExpr) {
+        const caseExpr = node.CaseExpr;
+        let chain = `${prefix}.case()`;
+        for (const w of (caseExpr.args || [])) {
+            if (w.CaseWhen) {
+                const condition = astToBuilder(w.CaseWhen.expr, opts);
+                const result = astToBuilder(w.CaseWhen.result, opts);
+                chain += `.when(${condition}, ${result})`;
+            }
+        }
+        if (caseExpr.defresult) {
+            const defResult = astToBuilder(caseExpr.defresult, opts);
+            chain += `.else(${defResult})`;
+        }
+        else {
+            chain += '.end()';
+        }
+        return chain;
+    }
+    const nodeType = Object.keys(node)[0];
+    throw new Error(`Unsupported AST node type in generated expression: "${nodeType}". Add explicit handling for this node type in astToBuilder.`);
+}
+function extractConcatItems(expr) {
+    if (expr.startsWith('__CONCAT__[')) {
+        const inner = expr.slice('__CONCAT__['.length, -1);
+        const items = [];
+        let depth = 0;
+        let current = '';
+        let inQuote = false;
+        for (let i = 0; i < inner.length; i++) {
+            const c = inner[i];
+            if (c === "'" && inner[i - 1] !== '\\') {
+                inQuote = !inQuote;
+            }
+            if (!inQuote) {
+                if (c === '[' || c === '(')
+                    depth++;
+                if (c === ']' || c === ')')
+                    depth--;
+                if (c === ',' && depth === 0) {
+                    items.push(current.trim());
+                    current = '';
+                    continue;
+                }
+            }
+            current += c;
+        }
+        if (current.trim())
+            items.push(current.trim());
+        return items.flatMap(item => extractConcatItems(item));
+    }
+    return [expr];
+}
+function cleanAllConcats(expr) {
+    let result = expr;
+    let iterations = 0;
+    const maxIterations = 50;
+    while (result.includes('__CONCAT__[') && iterations < maxIterations) {
+        const match = result.match(/__CONCAT__\[([^\[\]]*)\]/);
+        if (match) {
+            const replacement = `F.concat(${match[1]})`;
+            result = result.replace(match[0], replacement);
+        }
+        else {
+            break;
+        }
+        iterations++;
+    }
+    return result;
+}
+export function formatGeneratedExpression(expr) {
+    if (expr.startsWith('__CONCAT__[')) {
+        const items = extractConcatItems(expr);
+        const cleanedItems = items.map(item => cleanAllConcats(item));
+        return { isArray: true, items: cleanedItems };
+    }
+    const cleaned = cleanAllConcats(expr);
+    return { isArray: false, items: [cleaned] };
+}

package/dist/esm/cli/utils/ast/codegen/constraints.js

@@ -0,0 +1,176 @@
+import { toCamelCase, escapeString, isBalanced, getComparisonMethod } from "./utils.js";
+import { astToBuilder } from "./builder.js";
+let needsSqlImport = false;
+export function resetSqlImportFlag() {
+    needsSqlImport = false;
+}
+export function getSqlImportNeeded() {
+    return needsSqlImport;
+}
+export function extractEnumValues(expression) {
+    const anyMatch = expression.match(/ANY\s*\(\s*\(?(?:ARRAY)?\s*\[([^\]]+)\]/i);
+    if (anyMatch) {
+        const valuesStr = anyMatch[1];
+        const values = valuesStr.match(/'([^']+)'/g)?.map(v => v.replace(/'/g, '').replace(/::.*$/, '')) || [];
+        return values.length > 0 ? values : null;
+    }
+    const inMatch = expression.match(/\bIN\s*\(([^)]+)\)/i);
+    if (inMatch) {
+        const valuesStr = inMatch[1];
+        const values = valuesStr.match(/'([^']+)'/g)?.map(v => v.replace(/'/g, '')) || [];
+        return values.length > 0 ? values : null;
+    }
+    return null;
+}
+export function generateConstraintCode(constraints, useCamelCase) {
+    const lines = [];
+    for (const c of constraints) {
+        const cols = c.columns.map(col => `table.${useCamelCase ? toCamelCase(col) : col}`);
+        const commentOpt = c.comment ? `, comment: '${escapeString(c.comment)}'` : '';
+        if (c.type === 'PRIMARY KEY' && c.columns.length > 1) {
+            const nameOpt = c.name ? `name: '${c.name}', ` : '';
+            lines.push(`        constraint.primaryKey({ ${nameOpt}columns: [${cols.join(', ')}]${commentOpt} })`);
+        }
+        else if (c.type === 'UNIQUE' && c.columns.length > 1) {
+            const nameOpt = c.name ? `name: '${c.name}', ` : '';
+            lines.push(`        constraint.unique({ ${nameOpt}columns: [${cols.join(', ')}]${commentOpt} })`);
+        }
+        else if (c.type === 'EXCLUDE' && c.expression) {
+            const escapedExpr = escapeString(c.expression);
+            let line = `        constraint.exclude('${c.name}', '${escapedExpr}')`;
+            if (c.comment) {
+                line += `.comment('${escapeString(c.comment)}')`;
+            }
+            lines.push(line);
+        }
+    }
+    return lines;
+}
+export function generateForeignKeysOption(constraints) {
+    const fks = constraints.filter(c => c.type === 'FOREIGN KEY' && c.references);
+    if (fks.length === 0)
+        return null;
+    const entries = fks.map(fk => {
+        const cols = fk.columns.map(c => `'${c}'`).join(', ');
+        const refCols = fk.references.columns.map(c => `'${c}'`).join(', ');
+        let entry = `        { columns: [${cols}], references: { table: '${fk.references.table}', columns: [${refCols}] }`;
+        if (fk.references.onDelete && fk.references.onDelete !== 'NO ACTION') {
+            entry += `, onDelete: '${fk.references.onDelete}'`;
+        }
+        if (fk.references.onUpdate && fk.references.onUpdate !== 'NO ACTION') {
+            entry += `, onUpdate: '${fk.references.onUpdate}'`;
+        }
+        entry += ' }';
+        return entry;
+    });
+    return `    foreignKeys: [\n${entries.join(',\n')},\n    ]`;
+}
+export function generateCheckConstraintsOption(constraints, useCamelCase) {
+    const checks = constraints.filter(c => c.type === 'CHECK' && c.expression && !extractEnumValues(c.expression));
+    if (checks.length === 0)
+        return null;
+    const lines = checks.map(c => {
+        if (c.expressionAst) {
+            try {
+                const typedExpr = astToBuilder(c.expressionAst, {
+                    prefix: 'table',
+                    useCamelCase,
+                    useTableRef: true
+                });
+                return `        check.constraint('${c.name}', ${typedExpr})`;
+            }
+            catch {
+                const typedExpr = convertCheckExpressionToTyped(c.expression, useCamelCase);
+                return `        check.constraint('${c.name}', ${typedExpr})`;
+            }
+        }
+        const typedExpr = convertCheckExpressionToTyped(c.expression, useCamelCase);
+        return `        check.constraint('${c.name}', ${typedExpr})`;
+    });
+    return `    checkConstraints: (table, check) => [\n${lines.join(',\n')},\n    ]`;
+}
+export function convertCheckExpressionToTyped(expression, useCamelCase) {
+    const trimmed = expression.trim();
+    let expr = trimmed;
+    while (expr.startsWith('(') && expr.endsWith(')')) {
+        const inner = expr.slice(1, -1);
+        if (isBalanced(inner)) {
+            expr = inner;
+        }
+        else {
+            break;
+        }
+    }
+    const comparisonMatch = expr.match(/^(\w+)\s*(>=?|<=?|<>|!=|=)\s*\(?\s*(-?\d+(?:\.\d+)?)\s*\)?(?:::[\w\s]+)?$/i);
+    if (comparisonMatch) {
+        const [, column, op, value] = comparisonMatch;
+        const colName = useCamelCase ? toCamelCase(column) : column;
+        const method = getComparisonMethod(op);
+        return `table.${colName}.${method}(${value})`;
+    }
+    const isNotNullMatch = expr.match(/^(\w+)\s+IS\s+NOT\s+NULL$/i);
+    if (isNotNullMatch) {
+        const colName = useCamelCase ? toCamelCase(isNotNullMatch[1]) : isNotNullMatch[1];
+        return `table.${colName}.isNotNull()`;
+    }
+    const isNullMatch = expr.match(/^(\w+)\s+IS\s+NULL$/i);
+    if (isNullMatch) {
+        const colName = useCamelCase ? toCamelCase(isNullMatch[1]) : isNullMatch[1];
+        return `table.${colName}.isNull()`;
+    }
+    const betweenMatch = expr.match(/^(\w+)\s+BETWEEN\s+(-?\d+(?:\.\d+)?)\s+AND\s+(-?\d+(?:\.\d+)?)$/i);
+    if (betweenMatch) {
+        const [, column, min, max] = betweenMatch;
+        const colName = useCamelCase ? toCamelCase(column) : column;
+        return `table.${colName}.between(${min}, ${max})`;
+    }
+    const stringCompareMatch = expr.match(/^(\w+)\s*(=|<>|!=)\s*'([^']*)'(?:::[\w\s]+)?$/i);
+    if (stringCompareMatch) {
+        const [, column, op, value] = stringCompareMatch;
+        const colName = useCamelCase ? toCamelCase(column) : column;
+        const method = getComparisonMethod(op);
+        return `table.${colName}.${method}('${value}')`;
+    }
+    const colCompareMatch = expr.match(/^(\w+)\s*(>=?|<=?|<>|!=|=)\s*(\w+)$/i);
+    if (colCompareMatch) {
+        const [, col1, op, col2] = colCompareMatch;
+        const colName1 = useCamelCase ? toCamelCase(col1) : col1;
+        const colName2 = useCamelCase ? toCamelCase(col2) : col2;
+        const method = getComparisonMethod(op);
+        return `table.${colName1}.${method}(table.${colName2})`;
+    }
+    const lengthMatch = expr.match(/^length\((\w+)\)\s*(>=?|<=?|<>|!=|=)\s*(\d+)$/i);
+    if (lengthMatch) {
+        const [, column, op, value] = lengthMatch;
+        const colName = useCamelCase ? toCamelCase(column) : column;
+        const method = getComparisonMethod(op);
+        return `table.${colName}.asText().length().${method}(${value})`;
+    }
+    const andRangeMatch = expr.match(/^\((\w+)\s*(>=?)\s*(-?\d+(?:\.\d+)?)\)\s+AND\s+\(\1\s*(<=?)\s*(-?\d+(?:\.\d+)?)\)$/i);
+    if (andRangeMatch) {
+        const [, column, op1, min, op2, max] = andRangeMatch;
+        const colName = useCamelCase ? toCamelCase(column) : column;
+        const method1 = getComparisonMethod(op1);
+        const method2 = getComparisonMethod(op2);
+        return `table.${colName}.${method1}(${min}).and(table.${colName}.${method2}(${max}))`;
+    }
+    const andOpenRangeMatch = expr.match(/^\((\w+)\s*(>)\s*(-?\d+(?:\.\d+)?)\)\s+AND\s+\(\1\s*(<)\s*(-?\d+(?:\.\d+)?)\)$/i);
+    if (andOpenRangeMatch) {
+        const [, column, op1, min, op2, max] = andOpenRangeMatch;
+        const colName = useCamelCase ? toCamelCase(column) : column;
+        const method1 = getComparisonMethod(op1);
+        const method2 = getComparisonMethod(op2);
+        return `table.${colName}.${method1}(${min}).and(table.${colName}.${method2}(${max}))`;
+    }
+    const andMatch = expr.match(/^\((.+?)\)\s+AND\s+\((.+)\)$/i);
+    if (andMatch) {
+        const [, cond1, cond2] = andMatch;
+        const typed1 = convertCheckExpressionToTyped(`(${cond1})`, useCamelCase);
+        const typed2 = convertCheckExpressionToTyped(`(${cond2})`, useCamelCase);
+        if (!typed1.startsWith('sql`') && !typed2.startsWith('sql`')) {
+            return `${typed1}.and(${typed2})`;
+        }
+    }
+    needsSqlImport = true;
+    return `sql\`${escapeString(expression)}\``;
+}