relq 1.0.24 → 1.0.26

package/dist/esm/cli/utils/schema-to-ast.js

@@ -0,0 +1,447 @@
+export function isTableDefinition(value) {
+    return value && typeof value === 'object' &&
+        typeof value.$name === 'string' &&
+        typeof value.$columns === 'object' &&
+        typeof value.toSQL === 'function';
+}
+export function isEnumConfig(value) {
+    return value && typeof value === 'object' &&
+        typeof value.$enumName === 'string' &&
+        Array.isArray(value.$enumValues);
+}
+export function isDomainConfig(value) {
+    return value && typeof value === 'object' &&
+        typeof value.$domainName === 'string' &&
+        typeof value.$baseType === 'string';
+}
+export function isCompositeConfig(value) {
+    return value && typeof value === 'object' &&
+        typeof value.$typeName === 'string' &&
+        typeof value.$fields === 'object';
+}
+export function isSequenceConfig(value) {
+    return value && typeof value === 'object' &&
+        value._type === 'sequence' &&
+        typeof value.name === 'string';
+}
+export function isViewConfig(value) {
+    return value && typeof value === 'object' &&
+        value._type === 'view' &&
+        typeof value.name === 'string' &&
+        typeof value.definition === 'string';
+}
+export function isMaterializedViewConfig(value) {
+    return value && typeof value === 'object' &&
+        value._type === 'materialized_view' &&
+        typeof value.name === 'string' &&
+        typeof value.definition === 'string';
+}
+export function isFunctionConfig(value) {
+    return value && typeof value === 'object' &&
+        value.$type === 'function' &&
+        typeof value.$functionName === 'string';
+}
+export function isTriggerConfig(value) {
+    return value && typeof value === 'object' &&
+        value.$type === 'trigger' &&
+        typeof value.$triggerName === 'string';
+}
+export function isExtensionsConfig(value) {
+    return value && typeof value === 'object' &&
+        Array.isArray(value.extensions) &&
+        typeof value.toSQL === 'function';
+}
+export function isRelationsConfig(value) {
+    return value && typeof value === 'object' &&
+        value.$type === 'relations';
+}
+export function generateTrackingId() {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < 6; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+export function isValidTrackingId(id) {
+    return typeof id === 'string' && /^[a-z0-9]{6}$/.test(id);
+}
+export function extractTrackingId(obj) {
+    if (!obj)
+        return undefined;
+    if (typeof obj.$trackingId === 'string') {
+        return obj.$trackingId;
+    }
+    if (typeof obj.$id === 'function') {
+        const id = obj.$id();
+        if (typeof id === 'string') {
+            return id;
+        }
+    }
+    return undefined;
+}
+export function mapColumnTypeToPostgres(type) {
+    const typeMap = {
+        'UUID': 'uuid',
+        'TEXT': 'text',
+        'VARCHAR': 'character varying',
+        'CHAR': 'character',
+        'INTEGER': 'integer',
+        'INT': 'integer',
+        'BIGINT': 'bigint',
+        'SMALLINT': 'smallint',
+        'SERIAL': 'serial',
+        'BIGSERIAL': 'bigserial',
+        'SMALLSERIAL': 'smallserial',
+        'BOOLEAN': 'boolean',
+        'BOOL': 'boolean',
+        'REAL': 'real',
+        'FLOAT4': 'real',
+        'DOUBLE PRECISION': 'double precision',
+        'FLOAT8': 'double precision',
+        'NUMERIC': 'numeric',
+        'DECIMAL': 'numeric',
+        'MONEY': 'money',
+        'DATE': 'date',
+        'TIME': 'time without time zone',
+        'TIME WITH TIME ZONE': 'time with time zone',
+        'TIMETZ': 'time with time zone',
+        'TIMESTAMP': 'timestamp without time zone',
+        'TIMESTAMP WITH TIME ZONE': 'timestamp with time zone',
+        'TIMESTAMPTZ': 'timestamp with time zone',
+        'INTERVAL': 'interval',
+        'JSON': 'json',
+        'JSONB': 'jsonb',
+        'BYTEA': 'bytea',
+        'INET': 'inet',
+        'CIDR': 'cidr',
+        'MACADDR': 'macaddr',
+        'MACADDR8': 'macaddr8',
+        'POINT': 'point',
+        'LINE': 'line',
+        'LSEG': 'lseg',
+        'BOX': 'box',
+        'PATH': 'path',
+        'POLYGON': 'polygon',
+        'CIRCLE': 'circle',
+        'TSVECTOR': 'tsvector',
+        'TSQUERY': 'tsquery',
+        'XML': 'xml',
+        'BIT': 'bit',
+        'BIT VARYING': 'bit varying',
+        'VARBIT': 'bit varying',
+        'PG_LSN': 'pg_lsn',
+        'PG_SNAPSHOT': 'pg_snapshot',
+        'INT4RANGE': 'int4range',
+        'INT8RANGE': 'int8range',
+        'NUMRANGE': 'numrange',
+        'TSRANGE': 'tsrange',
+        'TSTZRANGE': 'tstzrange',
+        'DATERANGE': 'daterange',
+        'CITEXT': 'citext',
+        'LTREE': 'ltree',
+        'HSTORE': 'hstore',
+        'CUBE': 'cube',
+        'VECTOR': 'vector',
+    };
+    const upperType = type.toUpperCase();
+    return typeMap[upperType] || type.toLowerCase();
+}
+export function schemaToAST(schema) {
+    const result = {
+        enums: [],
+        domains: [],
+        compositeTypes: [],
+        sequences: [],
+        tables: [],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+    };
+    for (const [key, value] of Object.entries(schema)) {
+        if (!value)
+            continue;
+        if (isTableDefinition(value)) {
+            const table = tableToAST(value);
+            if (table)
+                result.tables.push(table);
+            continue;
+        }
+        if (isEnumConfig(value)) {
+            const enumDef = enumToAST(value);
+            if (enumDef)
+                result.enums.push(enumDef);
+            continue;
+        }
+        if (isDomainConfig(value)) {
+            const domain = domainToAST(value);
+            if (domain)
+                result.domains.push(domain);
+            continue;
+        }
+        if (isCompositeConfig(value)) {
+            const composite = compositeToAST(value);
+            if (composite)
+                result.compositeTypes.push(composite);
+            continue;
+        }
+        if (isSequenceConfig(value)) {
+            const sequence = sequenceToAST(value);
+            if (sequence)
+                result.sequences.push(sequence);
+            continue;
+        }
+        if (isViewConfig(value)) {
+            const view = viewToAST(value);
+            if (view)
+                result.views.push(view);
+            continue;
+        }
+        if (isMaterializedViewConfig(value)) {
+            const matView = materializedViewToAST(value);
+            if (matView)
+                result.views.push(matView);
+            continue;
+        }
+        if (isFunctionConfig(value)) {
+            const func = functionToAST(value);
+            if (func)
+                result.functions.push(func);
+            continue;
+        }
+        if (isTriggerConfig(value)) {
+            const trigger = triggerToAST(value);
+            if (trigger)
+                result.triggers.push(trigger);
+            continue;
+        }
+        if (isExtensionsConfig(value)) {
+            result.extensions.push(...value.extensions);
+            continue;
+        }
+    }
+    return result;
+}
+export function tableToAST(table) {
+    if (!isTableDefinition(table))
+        return null;
+    const columns = [];
+    for (const [colKey, colDef] of Object.entries(table.$columns || {})) {
+        const col = columnToAST(colDef, colKey);
+        if (col)
+            columns.push(col);
+    }
+    const indexes = [];
+    for (const idx of table.$indexes || []) {
+        const index = indexToAST(idx);
+        if (index)
+            indexes.push(index);
+    }
+    const constraints = [];
+    for (const con of table.$constraints || []) {
+        const constraint = constraintToAST(con);
+        if (constraint)
+            constraints.push(constraint);
+    }
+    return {
+        name: table.$name,
+        schema: table.$schema || 'public',
+        columns,
+        constraints,
+        indexes,
+        isPartitioned: !!table.$partitionBy,
+        partitionType: table.$partitionBy?.type?.toUpperCase(),
+        partitionKey: table.$partitionBy?.columns,
+        comment: table.$comment,
+        trackingId: extractTrackingId(table),
+    };
+}
+export function columnToAST(col, schemaKey) {
+    if (!col)
+        return null;
+    const config = col.$config || col;
+    return {
+        name: config.$sqlName || schemaKey,
+        type: mapColumnTypeToPostgres(config.$type || 'text'),
+        typeParams: {
+            precision: config.$precision,
+            scale: config.$scale,
+            length: config.$length,
+        },
+        isNullable: config.$nullable !== false,
+        isPrimaryKey: config.$primaryKey || false,
+        isUnique: config.$unique || false,
+        hasDefault: config.$default !== undefined,
+        defaultValue: config.$default?.toString(),
+        isGenerated: !!config.$generatedAlwaysAs,
+        generatedExpression: config.$generatedAlwaysAs?.toString(),
+        isArray: config.$isArray || false,
+        arrayDimensions: config.$arrayDimensions,
+        comment: config.$comment,
+        trackingId: extractTrackingId(config),
+    };
+}
+export function indexToAST(idx) {
+    if (!idx)
+        return null;
+    return {
+        name: idx.$name || idx.name,
+        columns: idx.$columns || idx.columns || [],
+        isUnique: idx.$unique || idx.unique || false,
+        method: idx.$using || idx.using || 'btree',
+        whereClause: idx.$where?.toString(),
+        includeColumns: idx.$include,
+        comment: idx.$comment,
+        trackingId: extractTrackingId(idx),
+    };
+}
+export function constraintToAST(con) {
+    if (!con)
+        return null;
+    return {
+        name: con.$name || con.name,
+        type: (con.$type || con.type || 'CHECK').toUpperCase(),
+        columns: con.$columns || con.columns || [],
+        expression: con.$expression || con.expression,
+        trackingId: extractTrackingId(con),
+    };
+}
+export function enumToAST(enumDef) {
+    if (!isEnumConfig(enumDef))
+        return null;
+    return {
+        name: enumDef.$enumName,
+        schema: enumDef.$schema || 'public',
+        values: [...enumDef.$enumValues],
+        trackingId: extractTrackingId(enumDef),
+    };
+}
+export function domainToAST(domain) {
+    if (!isDomainConfig(domain))
+        return null;
+    let checkExpression;
+    let checkName;
+    if (domain.$constraints && domain.$constraints.length > 0) {
+        const constraint = domain.$constraints[0];
+        const namedMatch = constraint.match(/^CONSTRAINT\s+(\w+)\s+CHECK\s*\((.+)\)$/i);
+        if (namedMatch) {
+            checkName = namedMatch[1];
+            checkExpression = namedMatch[2];
+        }
+        else {
+            const simpleMatch = constraint.match(/^CHECK\s*\((.+)\)$/i);
+            if (simpleMatch) {
+                checkExpression = simpleMatch[1];
+            }
+        }
+    }
+    return {
+        name: domain.$domainName,
+        schema: domain.$schema || 'public',
+        baseType: domain.$baseType,
+        notNull: domain.$notNull || false,
+        defaultValue: domain.$domainDefault?.toString(),
+        checkExpression,
+        checkName,
+        trackingId: extractTrackingId(domain),
+    };
+}
+export function compositeToAST(composite) {
+    if (!isCompositeConfig(composite))
+        return null;
+    const attributes = [];
+    for (const [fieldName, fieldDef] of Object.entries(composite.$fields || {})) {
+        const config = fieldDef.$config || fieldDef;
+        attributes.push({
+            name: fieldName,
+            type: config.$type || 'text',
+            collation: config.$collation,
+        });
+    }
+    return {
+        name: composite.$typeName,
+        schema: composite.$schema || 'public',
+        attributes,
+        trackingId: extractTrackingId(composite),
+    };
+}
+export function sequenceToAST(seq) {
+    if (!isSequenceConfig(seq))
+        return null;
+    return {
+        name: seq.name,
+        schema: seq.schema || 'public',
+        startValue: seq.options?.start,
+        increment: seq.options?.increment,
+        minValue: seq.options?.minValue,
+        maxValue: seq.options?.maxValue,
+        cache: seq.options?.cache,
+        cycle: seq.options?.cycle || false,
+        ownedBy: seq.options?.ownedBy,
+        trackingId: extractTrackingId(seq),
+    };
+}
+export function viewToAST(view) {
+    if (!isViewConfig(view))
+        return null;
+    return {
+        name: view.name,
+        schema: view.schema || 'public',
+        definition: view.definition,
+        isMaterialized: false,
+        trackingId: extractTrackingId(view),
+    };
+}
+export function materializedViewToAST(matView) {
+    if (!isMaterializedViewConfig(matView))
+        return null;
+    return {
+        name: matView.name,
+        schema: matView.schema || 'public',
+        definition: matView.definition,
+        isMaterialized: true,
+        withData: matView.withData,
+        trackingId: extractTrackingId(matView),
+    };
+}
+export function functionToAST(func) {
+    if (!isFunctionConfig(func))
+        return null;
+    const opts = func.$options || {};
+    return {
+        name: func.$functionName,
+        schema: opts.schema || 'public',
+        args: (opts.args || []).map((arg) => ({
+            name: arg.name,
+            type: arg.type,
+            mode: arg.mode,
+            default: arg.default,
+        })),
+        returnType: opts.returns || 'void',
+        language: opts.language || 'plpgsql',
+        body: opts.body || '',
+        volatility: opts.volatility?.toUpperCase(),
+        isStrict: opts.strict || false,
+        securityDefiner: opts.securityDefiner || false,
+        trackingId: extractTrackingId(func),
+    };
+}
+export function triggerToAST(trigger) {
+    if (!isTriggerConfig(trigger))
+        return null;
+    const opts = trigger.$options || {};
+    return {
+        name: trigger.$triggerName,
+        table: opts.table || '',
+        timing: (opts.timing || 'BEFORE').toUpperCase(),
+        events: (opts.events || ['INSERT']).map((e) => e.toUpperCase()),
+        forEach: (opts.forEach || 'ROW').toUpperCase(),
+        functionName: opts.execute || '',
+        whenClause: opts.when,
+        isConstraint: opts.constraint || false,
+        deferrable: opts.deferrable,
+        initiallyDeferred: opts.initiallyDeferred,
+        trackingId: extractTrackingId(trigger),
+    };
+}

package/dist/esm/cli/utils/schema-validator.js

@@ -52,7 +52,27 @@ export function validateSchemaFile(schemaPath) {
         getNewLine: () => '\n',
     });
     const syntacticDiagnostics = program.getSyntacticDiagnostics(sourceFile);
-    for (const diagnostic of syntacticDiagnostics) {
+    const ignoredErrorCodes = new Set([
+        2306,
+        2307,
+        2305,
+        2339,
+        2694,
+        2792,
+        2503,
+        2749,
+        2315,
+        2322,
+        2345,
+        2769,
+        2741,
+        2551,
+        2737,
+    ]);
+    const semanticDiagnostics = program.getSemanticDiagnostics(sourceFile)
+        .filter(d => !ignoredErrorCodes.has(d.code));
+    const allDiagnostics = [...syntacticDiagnostics, ...semanticDiagnostics];
+    for (const diagnostic of allDiagnostics) {
         if (diagnostic.file && diagnostic.start !== undefined) {
             const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
             errors.push({

package/dist/esm/schema-definition/column-types.js

@@ -228,6 +228,7 @@ const generatedFnMethods = {
     cast: (value, typeName) => chainableExpr(`(${formatGenValue(value)})::${typeName}`),
     func: (name, ...args) => chainableExpr(`${name.toUpperCase()}(${args.map(formatGenValue).join(', ')})`),
     sql: (expression) => chainableExpr(expression),
+    raw: (expression) => chainableExpr(expression),
     op: (left, operator, right) => chainableExpr(`(${formatGenValue(left)} ${operator} ${formatGenValue(right)})`),
     setweight: (tsvector, weight) => chainableExpr(`SETWEIGHT(${tsvector.$sql}, '${weight}')`),
     setWeight: (tsvector, weight) => chainableExpr(`SETWEIGHT(${tsvector.$sql}, '${weight}')`),
@@ -300,12 +301,18 @@ function createColumn(type) {
             return Object.assign(this, { $generated: config.$generated });
         },
         generatedAlwaysAs(callback, options) {
-            const tableProxy = new Proxy({}, {
-                get(_target, prop) {
-                    return chainableExpr(`"${prop}"`);
-                }
-            });
-            const result = callback(tableProxy, generatedFn);
+            let result;
+            if (callback.length === 1) {
+                result = callback(generatedFn);
+            }
+            else {
+                const tableProxy = new Proxy({}, {
+                    get(_target, prop) {
+                        return chainableExpr(`"${prop}"`);
+                    }
+                });
+                result = callback(tableProxy, generatedFn);
+            }
             const stored = options?.stored !== false;
             config.$generated = { expression: result.$sql, stored };
             return Object.assign(this, { $generated: config.$generated });
@@ -777,7 +784,21 @@ export function pgDomain(name, baseType, checks) {
         }
         return col;
     };
-    Object.assign(domainFn, {
+    let checkExpression;
+    let checkName;
+    if (constraints.length > 0) {
+        const firstConstraint = constraints[0];
+        const namedMatch = firstConstraint.match(/^CONSTRAINT\s+(\w+)\s+CHECK\s*\((.+)\)$/i);
+        const unnamedMatch = firstConstraint.match(/^CHECK\s*\((.+)\)$/i);
+        if (namedMatch) {
+            checkName = namedMatch[1];
+            checkExpression = namedMatch[2];
+        }
+        else if (unnamedMatch) {
+            checkExpression = unnamedMatch[1];
+        }
+    }
+    const domainConfig = {
         $domainName: name,
         $baseType: baseTypeStr,
         $constraints: constraints.length > 0 ? constraints : undefined,
@@ -785,7 +806,22 @@ export function pgDomain(name, baseType, checks) {
         $notNull: notNull,
         $columnBuilder: baseType,
         $validate: validateFn,
-    });
+        $trackingId: undefined,
+        toAST() {
+            return {
+                name: domainConfig.$domainName,
+                baseType: domainConfig.$baseType,
+                notNull: domainConfig.$notNull ?? false,
+                defaultValue: domainConfig.$domainDefault !== undefined
+                    ? String(domainConfig.$domainDefault)
+                    : undefined,
+                checkExpression,
+                checkName,
+                trackingId: domainConfig.$trackingId,
+            };
+        },
+    };
+    Object.assign(domainFn, domainConfig);
     return domainFn;
 }
 export function generateDomainSQL(domain) {
@@ -807,11 +843,28 @@ export function pgComposite(name, fields) {
         col.$fields = fields;
         return col;
     };
-    Object.assign(compositeFn, {
+    const attributes = Object.entries(fields).map(([fieldName, fieldConfig]) => {
+        const config = fieldConfig;
+        return {
+            name: fieldName,
+            type: config.$type,
+            collation: undefined,
+        };
+    });
+    const compositeConfig = {
         $typeName: name,
         $fields: fields,
         $inferType: {},
-    });
+        $trackingId: undefined,
+        toAST() {
+            return {
+                name: compositeConfig.$typeName,
+                attributes,
+                trackingId: compositeConfig.$trackingId,
+            };
+        },
+    };
+    Object.assign(compositeFn, compositeConfig);
     return compositeFn;
 }
 export function generateCompositeTypeSQL(composite) {

package/dist/esm/schema-definition/pg-enum.js

@@ -48,6 +48,16 @@ export function pgEnum(name, values) {
             },
             enumerable: true,
         },
+        toAST: {
+            value: function () {
+                return {
+                    name: this.$enumName,
+                    values: [...this.$enumValues],
+                    trackingId: this.$trackingId,
+                };
+            },
+            enumerable: true,
+        },
     });
     return config;
 }

package/dist/esm/schema-definition/pg-function.js

@@ -75,6 +75,25 @@ export function pgFunction(name, options) {
         $functionName: name,
         $options: options,
         $type: 'function',
+        toAST() {
+            const opts = this.$options;
+            return {
+                name: this.$functionName,
+                args: (opts.args || []).map(arg => ({
+                    name: arg.name,
+                    type: arg.type,
+                    mode: arg.mode,
+                    default: arg.default,
+                })),
+                returnType: opts.returns,
+                language: opts.language || 'plpgsql',
+                body: opts.body || opts.raw || '',
+                volatility: opts.volatility,
+                isStrict: opts.strict || false,
+                securityDefiner: opts.security === 'DEFINER',
+                trackingId: this.$trackingId,
+            };
+        },
     };
 }
 export function isFunctionConfig(value) {

package/dist/esm/schema-definition/pg-sequence.js

@@ -1,9 +1,30 @@
 export function pgSequence(name, options = {}) {
-    return {
+    const config = {
         _type: 'sequence',
         name,
         options,
+        toAST() {
+            return {
+                name: this.name,
+                startValue: this.options.start,
+                increment: this.options.increment,
+                minValue: this.options.minValue ?? undefined,
+                maxValue: this.options.maxValue ?? undefined,
+                cache: this.options.cache,
+                cycle: this.options.cycle ?? false,
+                ownedBy: this.options.ownedBy ? parseOwnedBy(this.options.ownedBy) : undefined,
+                trackingId: this.$trackingId,
+            };
+        },
     };
+    return config;
+}
+function parseOwnedBy(ownedBy) {
+    const parts = ownedBy.split('.');
+    if (parts.length === 2) {
+        return { table: parts[0], column: parts[1] };
+    }
+    return undefined;
 }
 export function generateSequenceSQL(seq) {
     const parts = [`CREATE SEQUENCE ${seq.name}`];