relq 1.0.4 → 1.0.6

package/dist/cjs/cli/utils/ast/codegen/constraints.cjs

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetSqlImportFlag = resetSqlImportFlag;
+exports.getSqlImportNeeded = getSqlImportNeeded;
+exports.extractEnumValues = extractEnumValues;
+exports.generateConstraintCode = generateConstraintCode;
+exports.generateForeignKeysOption = generateForeignKeysOption;
+exports.generateCheckConstraintsOption = generateCheckConstraintsOption;
+exports.convertCheckExpressionToTyped = convertCheckExpressionToTyped;
+const utils_1 = require("./utils.cjs");
+const builder_1 = require("./builder.cjs");
+let needsSqlImport = false;
+function resetSqlImportFlag() {
+    needsSqlImport = false;
+}
+function getSqlImportNeeded() {
+    return needsSqlImport;
+}
+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;
+}
+function generateConstraintCode(constraints, useCamelCase) {
+    const lines = [];
+    for (const c of constraints) {
+        const cols = c.columns.map(col => `table.${useCamelCase ? (0, utils_1.toCamelCase)(col) : col}`);
+        const commentOpt = c.comment ? `, comment: '${(0, utils_1.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 = (0, utils_1.escapeString)(c.expression);
+            let line = `        constraint.exclude('${c.name}', '${escapedExpr}')`;
+            if (c.comment) {
+                line += `.comment('${(0, utils_1.escapeString)(c.comment)}')`;
+            }
+            lines.push(line);
+        }
+    }
+    return lines;
+}
+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    ]`;
+}
+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 = (0, builder_1.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    ]`;
+}
+function convertCheckExpressionToTyped(expression, useCamelCase) {
+    const trimmed = expression.trim();
+    let expr = trimmed;
+    while (expr.startsWith('(') && expr.endsWith(')')) {
+        const inner = expr.slice(1, -1);
+        if ((0, utils_1.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 ? (0, utils_1.toCamelCase)(column) : column;
+        const method = (0, utils_1.getComparisonMethod)(op);
+        return `table.${colName}.${method}(${value})`;
+    }
+    const isNotNullMatch = expr.match(/^(\w+)\s+IS\s+NOT\s+NULL$/i);
+    if (isNotNullMatch) {
+        const colName = useCamelCase ? (0, utils_1.toCamelCase)(isNotNullMatch[1]) : isNotNullMatch[1];
+        return `table.${colName}.isNotNull()`;
+    }
+    const isNullMatch = expr.match(/^(\w+)\s+IS\s+NULL$/i);
+    if (isNullMatch) {
+        const colName = useCamelCase ? (0, utils_1.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 ? (0, utils_1.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 ? (0, utils_1.toCamelCase)(column) : column;
+        const method = (0, utils_1.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 ? (0, utils_1.toCamelCase)(col1) : col1;
+        const colName2 = useCamelCase ? (0, utils_1.toCamelCase)(col2) : col2;
+        const method = (0, utils_1.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 ? (0, utils_1.toCamelCase)(column) : column;
+        const method = (0, utils_1.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 ? (0, utils_1.toCamelCase)(column) : column;
+        const method1 = (0, utils_1.getComparisonMethod)(op1);
+        const method2 = (0, utils_1.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 ? (0, utils_1.toCamelCase)(column) : column;
+        const method1 = (0, utils_1.getComparisonMethod)(op1);
+        const method2 = (0, utils_1.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\`${(0, utils_1.escapeString)(expression)}\``;
+}

package/dist/cjs/cli/utils/ast/codegen/defaults.cjs

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetDefaultImportFlags = resetDefaultImportFlags;
+exports.getDefaultImportNeeded = getDefaultImportNeeded;
+exports.getDefaultSqlImportNeeded = getDefaultSqlImportNeeded;
+exports.formatDefaultValue = formatDefaultValue;
+const utils_1 = require("./utils.cjs");
+let needsDefaultImport = false;
+let needsSqlImport = false;
+function resetDefaultImportFlags() {
+    needsDefaultImport = false;
+    needsSqlImport = false;
+}
+function getDefaultImportNeeded() {
+    return needsDefaultImport;
+}
+function getDefaultSqlImportNeeded() {
+    return needsSqlImport;
+}
+function formatDefaultValue(value, columnType) {
+    if (!value)
+        return "''";
+    const trimmed = value.trim();
+    const upper = trimmed.toUpperCase();
+    if (upper === 'TRUE')
+        return 'true';
+    if (upper === 'FALSE')
+        return 'false';
+    if (upper === 'NULL')
+        return 'null';
+    if (upper === 'GEN_RANDOM_UUID()' || upper.includes('GEN_RANDOM_UUID')) {
+        needsDefaultImport = true;
+        return 'DEFAULT.genRandomUuid()';
+    }
+    if (upper === 'UUID_GENERATE_V4()' || upper.includes('UUID_GENERATE_V4')) {
+        needsDefaultImport = true;
+        return 'DEFAULT.uuidGenerateV4()';
+    }
+    if (upper === 'UUID_GENERATE_V1()' || upper.includes('UUID_GENERATE_V1()')) {
+        needsDefaultImport = true;
+        return 'DEFAULT.uuidGenerateV1()';
+    }
+    if (upper === 'UUID_GENERATE_V1MC()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.uuidGenerateV1mc()';
+    }
+    if (upper === 'UUID_NIL()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.uuidNil()';
+    }
+    if (upper === 'NOW()' || upper === 'NOW') {
+        needsDefaultImport = true;
+        return 'DEFAULT.now()';
+    }
+    if (upper === 'CURRENT_TIMESTAMP' || upper === 'CURRENT_TIMESTAMP()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.currentTimestamp()';
+    }
+    if (upper === 'CURRENT_DATE' || upper === 'CURRENT_DATE()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.currentDate()';
+    }
+    if (upper === 'CURRENT_TIME' || upper === 'CURRENT_TIME()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.currentTime()';
+    }
+    if (upper === 'LOCALTIMESTAMP' || upper === 'LOCALTIMESTAMP()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.localTimestamp()';
+    }
+    if (upper === 'LOCALTIME' || upper === 'LOCALTIME()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.localTime()';
+    }
+    if (upper === 'TRANSACTION_TIMESTAMP()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.transactionTimestamp()';
+    }
+    if (upper === 'STATEMENT_TIMESTAMP()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.statementTimestamp()';
+    }
+    if (upper === 'CLOCK_TIMESTAMP()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.clockTimestamp()';
+    }
+    if (upper === 'TIMEOFDAY()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.timeofday()';
+    }
+    const intervalMatch = trimmed.match(/^'([^']+)'::interval$/i);
+    if (intervalMatch) {
+        needsDefaultImport = true;
+        return `DEFAULT.interval('${intervalMatch[1]}')`;
+    }
+    if (upper === 'CURRENT_USER' || upper === 'CURRENT_USER()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.currentUser()';
+    }
+    if (upper === 'SESSION_USER' || upper === 'SESSION_USER()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.sessionUser()';
+    }
+    if (upper === 'USER' || upper === 'USER()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.user()';
+    }
+    if (upper === 'CURRENT_SCHEMA()' || upper === 'CURRENT_SCHEMA') {
+        needsDefaultImport = true;
+        return 'DEFAULT.currentSchema()';
+    }
+    if (upper === 'CURRENT_DATABASE()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.currentDatabase()';
+    }
+    if (upper === 'CURRENT_CATALOG' || upper === 'CURRENT_CATALOG()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.currentCatalog()';
+    }
+    if (upper === 'INET_CLIENT_ADDR()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.inetClientAddr()';
+    }
+    if (upper === 'INET_SERVER_ADDR()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.inetServerAddr()';
+    }
+    if (upper === 'PG_BACKEND_PID()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.pgBackendPid()';
+    }
+    const nextvalMatch = trimmed.match(/^nextval\('([^']+)'(?:::regclass)?\)$/i);
+    if (nextvalMatch) {
+        needsDefaultImport = true;
+        return `DEFAULT.nextval('${nextvalMatch[1]}')`;
+    }
+    const currvalMatch = trimmed.match(/^currval\('([^']+)'(?:::regclass)?\)$/i);
+    if (currvalMatch) {
+        needsDefaultImport = true;
+        return `DEFAULT.currval('${currvalMatch[1]}')`;
+    }
+    if (upper === 'LASTVAL()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.lastval()';
+    }
+    if (upper === 'RANDOM()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.random()';
+    }
+    if (upper === 'PI()') {
+        needsDefaultImport = true;
+        return 'DEFAULT.pi()';
+    }
+    if (trimmed === "''" || trimmed === '""') {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyString()';
+    }
+    if (trimmed === "'{}'::jsonb" || upper === "'{}'::JSONB") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyJsonb()';
+    }
+    if (trimmed === "'{}'::json" || upper === "'{}'::JSON") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyJson()';
+    }
+    if (trimmed === "'{}'" || trimmed === "'{}'") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyObject()';
+    }
+    if (trimmed === "'[]'::jsonb" || upper === "'[]'::JSONB" || trimmed === "'[]'::json" || upper === "'[]'::JSON") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyArray()';
+    }
+    const emptyArrayMatch = trimmed.match(/^ARRAY\[\]::(\w+)\[\]$/i);
+    if (emptyArrayMatch) {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyArray()';
+    }
+    const emptyArrayLiteralMatch = trimmed.match(/^'\{\}'::(\w+)\[\]$/i);
+    if (emptyArrayLiteralMatch) {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyArray()';
+    }
+    if (upper === "'EMPTY'::INT4RANGE") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyInt4range()';
+    }
+    if (upper === "'EMPTY'::INT8RANGE") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyInt8range()';
+    }
+    if (upper === "'EMPTY'::NUMRANGE") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyNumrange()';
+    }
+    if (upper === "'EMPTY'::TSRANGE") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyTsrange()';
+    }
+    if (upper === "'EMPTY'::TSTZRANGE") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyTstzrange()';
+    }
+    if (upper === "'EMPTY'::DATERANGE") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyDaterange()';
+    }
+    if (upper === "''::TSVECTOR") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyTsvector()';
+    }
+    if (upper === "''::HSTORE") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyHstore()';
+    }
+    if (trimmed === "'\\x'::bytea" || upper === "'\\X'::BYTEA") {
+        needsDefaultImport = true;
+        return 'DEFAULT.emptyBytea()';
+    }
+    const moneyMatch = trimmed.match(/^'([^']+)'::money$/i);
+    if (moneyMatch) {
+        needsDefaultImport = true;
+        if (moneyMatch[1] === '0' || moneyMatch[1] === '0.00') {
+            return 'DEFAULT.zeroMoney()';
+        }
+        return `DEFAULT.money('${moneyMatch[1]}')`;
+    }
+    const inetMatch = trimmed.match(/^'([^']+)'::inet$/i);
+    if (inetMatch) {
+        needsDefaultImport = true;
+        return `DEFAULT.inet('${inetMatch[1]}')`;
+    }
+    const cidrMatch = trimmed.match(/^'([^']+)'::cidr$/i);
+    if (cidrMatch) {
+        needsDefaultImport = true;
+        return `DEFAULT.cidr('${cidrMatch[1]}')`;
+    }
+    const macaddrMatch = trimmed.match(/^'([^']+)'::macaddr$/i);
+    if (macaddrMatch) {
+        needsDefaultImport = true;
+        return `DEFAULT.macaddr('${macaddrMatch[1]}')`;
+    }
+    const pointMatch = trimmed.match(/^point\(([^,]+),\s*([^)]+)\)$/i);
+    if (pointMatch) {
+        needsDefaultImport = true;
+        return `DEFAULT.point(${pointMatch[1]}, ${pointMatch[2]})`;
+    }
+    const castMatch = trimmed.match(/^'([^']*)'::(.+)$/i);
+    if (castMatch) {
+        const castValue = castMatch[1];
+        const castType = castMatch[2].toLowerCase().trim();
+        if ((castType === 'jsonb' || castType === 'json') && castValue.startsWith('[')) {
+            try {
+                const parsed = JSON.parse(castValue);
+                return JSON.stringify(parsed);
+            }
+            catch {
+            }
+        }
+        if ((castType === 'jsonb' || castType === 'json') && castValue.startsWith('{')) {
+            try {
+                const parsed = JSON.parse(castValue);
+                return JSON.stringify(parsed);
+            }
+            catch {
+            }
+        }
+        if (['varchar', 'text', 'char', 'bpchar', 'character', 'character varying'].includes(castType)) {
+            return `'${castValue.replace(/'/g, "\\'")}'`;
+        }
+        if (['int', 'int2', 'int4', 'int8', 'integer', 'smallint', 'bigint'].includes(castType)) {
+            const num = parseInt(castValue, 10);
+            if (!isNaN(num)) {
+                if (castType === 'int8' || castType === 'bigint') {
+                    return `${num}n`;
+                }
+                return String(num);
+            }
+        }
+        if (castType === 'boolean' || castType === 'bool') {
+            return castValue.toLowerCase() === 'true' ? 'true' : 'false';
+        }
+        if (['numeric', 'decimal', 'real', 'float', 'float4', 'float8', 'double precision'].includes(castType)) {
+            const num = parseFloat(castValue);
+            if (!isNaN(num)) {
+                return String(num);
+            }
+        }
+        return `'${castValue.replace(/'/g, "\\'")}'`;
+    }
+    const normalizedColType = columnType?.toLowerCase().trim();
+    const isBigintColumn = normalizedColType === 'int8' || normalizedColType === 'bigint';
+    if (/^-?\d+$/.test(trimmed)) {
+        if (isBigintColumn) {
+            return `${trimmed}n`;
+        }
+        return trimmed;
+    }
+    if (/^-?\d+\.\d+$/.test(trimmed)) {
+        return trimmed;
+    }
+    if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        const inner = trimmed.slice(1, -1);
+        return `'${inner.replace(/'/g, "\\'")}'`;
+    }
+    if (/^CAST\s*\(\s*(?:'?\{\}'?|ARRAY\s*\[\s*\])\s+AS\s+\w+\s*\[\s*\]\s*\)$/i.test(trimmed)) {
+        return '[]';
+    }
+    needsSqlImport = true;
+    return `sql\`${(0, utils_1.escapeString)(trimmed)}\``;
+}

package/dist/cjs/cli/utils/ast/codegen/index.cjs

@@ -0,0 +1,24 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypeScriptFromAST = void 0;
+__exportStar(require("./utils.cjs"), exports);
+__exportStar(require("./builder.cjs"), exports);
+__exportStar(require("./type-map.cjs"), exports);
+__exportStar(require("./defaults.cjs"), exports);
+__exportStar(require("./constraints.cjs"), exports);
+var ast_codegen_1 = require("../../ast-codegen.cjs");
+Object.defineProperty(exports, "generateTypeScriptFromAST", { enumerable: true, get: function () { return ast_codegen_1.generateTypeScriptFromAST; } });

package/dist/cjs/cli/utils/ast/codegen/type-map.cjs

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPE_MAP = void 0;
+exports.getColumnBuilder = getColumnBuilder;
+exports.getColumnBuilderWithInfo = getColumnBuilderWithInfo;
+exports.TYPE_MAP = {
+    'int2': 'smallint',
+    'int4': 'integer',
+    'int8': 'bigint',
+    'smallint': 'smallint',
+    'integer': 'integer',
+    'bigint': 'bigint',
+    'serial': 'serial',
+    'smallserial': 'smallserial',
+    'bigserial': 'bigserial',
+    'float4': 'real',
+    'float8': 'doublePrecision',
+    'real': 'real',
+    'double precision': 'doublePrecision',
+    'numeric': 'numeric',
+    'decimal': 'numeric',
+    'money': 'money',
+    'text': 'text',
+    'varchar': 'varchar',
+    'character varying': 'varchar',
+    'char': 'char',
+    'character': 'char',
+    'bpchar': 'char',
+    'citext': 'citext',
+    'name': 'name',
+    'bytea': 'bytea',
+    'bool': 'boolean',
+    'boolean': 'boolean',
+    'date': 'date',
+    'time': 'time',
+    'timetz': 'timetz',
+    'timestamp': 'timestamp',
+    'timestamptz': 'timestamptz',
+    'interval': 'interval',
+    'uuid': 'uuid',
+    'json': 'json',
+    'jsonb': 'jsonb',
+    'inet': 'inet',
+    'cidr': 'cidr',
+    'macaddr': 'macaddr',
+    'macaddr8': 'macaddr8',
+    'point': 'point',
+    'line': 'line',
+    'lseg': 'lseg',
+    'box': 'box',
+    'path': 'path',
+    'polygon': 'polygon',
+    'circle': 'circle',
+    'int4range': 'int4range',
+    'int8range': 'int8range',
+    'numrange': 'numrange',
+    'tsrange': 'tsrange',
+    'tstzrange': 'tstzrange',
+    'daterange': 'daterange',
+    'tsvector': 'tsvector',
+    'tsquery': 'tsquery',
+    'xml': 'xml',
+    'bit': 'bit',
+    'varbit': 'varbit',
+    'ltree': 'ltree',
+    'cube': 'cube',
+    'hstore': 'hstore',
+};
+function getColumnBuilder(type, params) {
+    const result = getColumnBuilderWithInfo(type, params);
+    if (result.length != null) {
+        return `${result.builderName}(${result.length})`;
+    }
+    return result.builder;
+}
+function getColumnBuilderWithInfo(type, params) {
+    const normalizedType = type.toLowerCase().trim();
+    const builderName = exports.TYPE_MAP[normalizedType] || 'text';
+    let builder = `${builderName}()`;
+    let length;
+    if (params) {
+        if ((builderName === 'varchar' || builderName === 'char') && params.length) {
+            length = params.length;
+        }
+        else if (builderName === 'numeric' && params.precision != null) {
+            if (params.scale != null && params.scale > 0) {
+                builder = `numeric(${params.precision}, ${params.scale})`;
+            }
+            else {
+                builder = `numeric(${params.precision})`;
+            }
+        }
+        else if (builderName === 'bit' && params.length) {
+            builder = `bit(${params.length})`;
+        }
+        else if (builderName === 'varbit' && params.length) {
+            builder = `varbit(${params.length})`;
+        }
+        else if (builderName === 'time' && params.precision != null) {
+            builder = `time(${params.precision})`;
+        }
+        else if (builderName === 'timetz' && params.precision != null) {
+            builder = `timetz(${params.precision})`;
+        }
+        else if (builderName === 'timestamp' && params.precision != null) {
+            builder = `timestamp(${params.precision})`;
+        }
+        else if (builderName === 'timestamptz' && params.precision != null) {
+            builder = `timestamptz(${params.precision})`;
+        }
+        else if (builderName === 'interval' && params.precision != null) {
+            builder = `interval(${params.precision})`;
+        }
+    }
+    return { builder, builderName, length };
+}