relq 1.0.5 → 1.0.6

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCase = toCamelCase;
+exports.toPascalCase = toPascalCase;
+exports.escapeString = escapeString;
+exports.escapeJsDocString = escapeJsDocString;
+exports.pluralize = pluralize;
+exports.isBalanced = isBalanced;
+exports.getComparisonMethod = getComparisonMethod;
+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('');
+}
+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('');
+}
+function escapeString(str) {
+    return str.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+function escapeJsDocString(str) {
+    return str.replace(/\*\//g, '*\\/').replace(/\n/g, '\n * ');
+}
+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';
+}
+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;
+}
+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/cjs/cli/utils/ast/index.cjs

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./codegen/index.cjs"), exports);
+__exportStar(require("./transformer/index.cjs"), exports);

package/dist/cjs/cli/utils/ast/transformer/helpers.cjs

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTypeName = extractTypeName;
+exports.extractConstraintType = extractConstraintType;
+exports.extractFkAction = extractFkAction;
+exports.extractFkMatch = extractFkMatch;
+exports.deparseNode = deparseNode;
+exports.normalizeTypeName = normalizeTypeName;
+exports.extractTypeParams = extractTypeParams;
+exports.extractColumnsFromDefinition = extractColumnsFromDefinition;
+exports.extractCheckExpression = extractCheckExpression;
+exports.extractExcludeExpression = extractExcludeExpression;
+exports.parseArgTypes = parseArgTypes;
+const pgsql_deparser_1 = require("pgsql-deparser");
+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 };
+}
+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';
+}
+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];
+}
+function extractFkMatch(matchType) {
+    if (!matchType)
+        return undefined;
+    const matches = {
+        's': 'SIMPLE',
+        'f': 'FULL',
+    };
+    return matches[matchType];
+}
+async function deparseNode(node) {
+    try {
+        const result = await (0, pgsql_deparser_1.deparse)([node]);
+        return result.trim();
+    }
+    catch {
+        return '';
+    }
+}
+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;
+}
+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;
+}
+function extractColumnsFromDefinition(definition) {
+    const match = definition.match(/\(([^)]+)\)/);
+    if (!match)
+        return [];
+    return match[1].split(',').map(s => s.trim().replace(/"/g, ''));
+}
+function extractCheckExpression(definition) {
+    const match = definition.match(/CHECK\s*\((.+)\)/is);
+    return match ? match[1].trim() : definition;
+}
+function extractExcludeExpression(definition) {
+    const match = definition.match(/EXCLUDE\s+USING\s+\w+\s*\((.+)\)/is);
+    return match ? match[1].trim() : definition;
+}
+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/cjs/cli/utils/ast/transformer/index.cjs

@@ -0,0 +1,25 @@
+"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.deparse = exports.parse = exports.normalizedToParsedSchema = exports.introspectedToParsedSchema = exports.deparseSchema = exports.parseSQL = void 0;
+__exportStar(require("./helpers.cjs"), exports);
+var ast_transformer_1 = require("../../ast-transformer.cjs");
+Object.defineProperty(exports, "parseSQL", { enumerable: true, get: function () { return ast_transformer_1.parseSQL; } });
+Object.defineProperty(exports, "deparseSchema", { enumerable: true, get: function () { return ast_transformer_1.deparseSchema; } });
+Object.defineProperty(exports, "introspectedToParsedSchema", { enumerable: true, get: function () { return ast_transformer_1.introspectedToParsedSchema; } });
+Object.defineProperty(exports, "normalizedToParsedSchema", { enumerable: true, get: function () { return ast_transformer_1.normalizedToParsedSchema; } });
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return ast_transformer_1.parse; } });
+Object.defineProperty(exports, "deparse", { enumerable: true, get: function () { return ast_transformer_1.deparse; } });

package/dist/cjs/cli/utils/ast/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });