relq 1.0.4 → 1.0.6

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

@@ -0,0 +1,305 @@
+import { escapeString } from "./utils.js";
+let needsDefaultImport = false;
+let needsSqlImport = false;
+export function resetDefaultImportFlags() {
+    needsDefaultImport = false;
+    needsSqlImport = false;
+}
+export function getDefaultImportNeeded() {
+    return needsDefaultImport;
+}
+export function getDefaultSqlImportNeeded() {
+    return needsSqlImport;
+}
+export 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\`${escapeString(trimmed)}\``;
+}

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

@@ -0,0 +1,6 @@
+export * from "./utils.js";
+export * from "./builder.js";
+export * from "./type-map.js";
+export * from "./defaults.js";
+export * from "./constraints.js";
+export { generateTypeScriptFromAST } from "../../ast-codegen.js";

package/dist/esm/cli/utils/ast/codegen/type-map.js

@@ -0,0 +1,111 @@
+export const 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',
+};
+export function getColumnBuilder(type, params) {
+    const result = getColumnBuilderWithInfo(type, params);
+    if (result.length != null) {
+        return `${result.builderName}(${result.length})`;
+    }
+    return result.builder;
+}
+export function getColumnBuilderWithInfo(type, params) {
+    const normalizedType = type.toLowerCase().trim();
+    const builderName = 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 };
+}

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

@@ -0,0 +1,60 @@
+export function toCamelCase(str) {
+    if (!str)
+        return 'unknown';
+    const cleaned = str.replace(/^[_0-9]+/, '');
+    return cleaned
+        .split('_')
+        .map((word, i) => i === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+export function toPascalCase(str) {
+    if (!str)
+        return 'Unknown';
+    const cleaned = str.replace(/^[_0-9]+/, '');
+    return cleaned
+        .split('_')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+export function escapeString(str) {
+    return str.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+export function escapeJsDocString(str) {
+    return str.replace(/\*\//g, '*\\/').replace(/\n/g, '\n * ');
+}
+export function pluralize(word) {
+    if (!word)
+        return word;
+    if (word.endsWith('s') || word.endsWith('x') || word.endsWith('z') ||
+        word.endsWith('ch') || word.endsWith('sh')) {
+        return word + 'es';
+    }
+    if (word.endsWith('y') && !['a', 'e', 'i', 'o', 'u'].includes(word[word.length - 2])) {
+        return word.slice(0, -1) + 'ies';
+    }
+    return word + 's';
+}
+export function isBalanced(str) {
+    let count = 0;
+    for (const char of str) {
+        if (char === '(')
+            count++;
+        if (char === ')')
+            count--;
+        if (count < 0)
+            return false;
+    }
+    return count === 0;
+}
+export function getComparisonMethod(op) {
+    switch (op) {
+        case '>': return 'gt';
+        case '>=': return 'gte';
+        case '<': return 'lt';
+        case '<=': return 'lte';
+        case '=': return 'eq';
+        case '<>':
+        case '!=': return 'neq';
+        default: return 'eq';
+    }
+}

package/dist/esm/cli/utils/ast/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./codegen/index.js";
+export * from "./transformer/index.js";

package/dist/esm/cli/utils/ast/transformer/helpers.js

@@ -0,0 +1,141 @@
+import { deparse } from 'pgsql-deparser';
+export function extractTypeName(typeName) {
+    if (!typeName)
+        return { name: 'text', isArray: false };
+    const names = typeName.names?.map((n) => n.String?.sval).filter(Boolean) || [];
+    let name = names.length > 1 ? names[names.length - 1] : names[0] || 'text';
+    if (names[0] === 'pg_catalog') {
+        name = names[1] || 'text';
+    }
+    const isArray = (typeName.arrayBounds?.length ?? 0) > 0;
+    const arrayDims = typeName.arrayBounds?.length;
+    let params;
+    if (typeName.typmods && typeName.typmods.length > 0) {
+        const mods = typeName.typmods.map((m) => {
+            if (m.A_Const?.ival?.ival !== undefined)
+                return m.A_Const.ival.ival;
+            if (m.A_Const?.sval?.sval !== undefined)
+                return m.A_Const.sval.sval;
+            return undefined;
+        }).filter((v) => v !== undefined);
+        if (mods.length === 1) {
+            if (['varchar', 'character varying', 'char', 'character', 'bit', 'varbit'].includes(name.toLowerCase())) {
+                params = { length: mods[0] };
+            }
+            else {
+                params = { precision: mods[0] };
+            }
+        }
+        else if (mods.length === 2) {
+            params = { precision: mods[0], scale: mods[1] };
+        }
+    }
+    return { name, params, isArray, arrayDims };
+}
+export function extractConstraintType(contype) {
+    const types = {
+        0: 'NULL',
+        1: 'NOT NULL',
+        2: 'DEFAULT',
+        3: 'IDENTITY',
+        4: 'GENERATED',
+        5: 'CHECK',
+        6: 'PRIMARY KEY',
+        7: 'UNIQUE',
+        8: 'EXCLUSION',
+        9: 'FOREIGN KEY',
+    };
+    return types[contype] || 'UNKNOWN';
+}
+export function extractFkAction(action) {
+    if (!action)
+        return undefined;
+    const actions = {
+        'a': 'NO ACTION',
+        'r': 'RESTRICT',
+        'c': 'CASCADE',
+        'n': 'SET NULL',
+        'd': 'SET DEFAULT',
+    };
+    return actions[action];
+}
+export function extractFkMatch(matchType) {
+    if (!matchType)
+        return undefined;
+    const matches = {
+        's': 'SIMPLE',
+        'f': 'FULL',
+    };
+    return matches[matchType];
+}
+export async function deparseNode(node) {
+    try {
+        const result = await deparse([node]);
+        return result.trim();
+    }
+    catch {
+        return '';
+    }
+}
+export function normalizeTypeName(dataType, udtName) {
+    if (dataType === 'ARRAY' && udtName) {
+        const baseType = udtName.replace(/^_/, '');
+        return baseType;
+    }
+    const typeMap = {
+        'integer': 'int4',
+        'smallint': 'int2',
+        'bigint': 'int8',
+        'real': 'float4',
+        'double precision': 'float8',
+        'character varying': 'varchar',
+        'character': 'char',
+        'boolean': 'bool',
+        'timestamp without time zone': 'timestamp',
+        'timestamp with time zone': 'timestamptz',
+        'time without time zone': 'time',
+        'time with time zone': 'timetz',
+    };
+    const lower = dataType.toLowerCase();
+    return typeMap[lower] || udtName || lower;
+}
+export function extractTypeParams(col) {
+    if (col.characterMaxLength) {
+        return { length: col.characterMaxLength };
+    }
+    if (col.numericPrecision != null) {
+        if (col.numericScale != null && col.numericScale > 0) {
+            return { precision: col.numericPrecision, scale: col.numericScale };
+        }
+        return { precision: col.numericPrecision };
+    }
+    return undefined;
+}
+export function extractColumnsFromDefinition(definition) {
+    const match = definition.match(/\(([^)]+)\)/);
+    if (!match)
+        return [];
+    return match[1].split(',').map(s => s.trim().replace(/"/g, ''));
+}
+export function extractCheckExpression(definition) {
+    const match = definition.match(/CHECK\s*\((.+)\)/is);
+    return match ? match[1].trim() : definition;
+}
+export function extractExcludeExpression(definition) {
+    const match = definition.match(/EXCLUDE\s+USING\s+\w+\s*\((.+)\)/is);
+    return match ? match[1].trim() : definition;
+}
+export function parseArgTypes(argTypes) {
+    if (!argTypes)
+        return [];
+    if (Array.isArray(argTypes)) {
+        return argTypes.map(t => ({ type: t }));
+    }
+    return argTypes.split(',').map(arg => {
+        const parts = arg.trim().split(/\s+/);
+        if (parts.length > 1) {
+            return { name: parts[0], type: parts.slice(1).join(' ') };
+        }
+        return { type: parts[0] };
+    }).filter(a => a.type);
+}

package/dist/esm/cli/utils/ast/transformer/index.js

@@ -0,0 +1,2 @@
+export * from "./helpers.js";
+export { parseSQL, deparseSchema, introspectedToParsedSchema, normalizedToParsedSchema, parse, deparse, } from "../../ast-transformer.js";

package/dist/esm/cli/utils/ast/types.js

@@ -0,0 +1 @@
+export {};