relq 1.0.0

package/dist/esm/schema-definition/partitions.js

@@ -0,0 +1,123 @@
+function getColumnName(column) {
+    if (typeof column === 'string')
+        return column;
+    return column.$columnName || column.name || 'unknown';
+}
+function createListBuilder(column) {
+    const builder = {
+        $type: 'LIST',
+        $column: column,
+        sub(fn) {
+            const subStrategy = fn(partitionStrategyFactory);
+            return {
+                ...this,
+                $subpartition: subStrategy,
+            };
+        },
+    };
+    return builder;
+}
+function createRangeBuilder(column) {
+    const builder = {
+        $type: 'RANGE',
+        $column: column,
+        sub(fn) {
+            const subStrategy = fn(partitionStrategyFactory);
+            return {
+                ...this,
+                $subpartition: subStrategy,
+            };
+        },
+    };
+    return builder;
+}
+function createHashBuilder(column, modulus) {
+    return {
+        $type: 'HASH',
+        $column: column,
+        $modulus: modulus,
+    };
+}
+export const partitionStrategyFactory = {
+    list(column) {
+        return createListBuilder(getColumnName(column));
+    },
+    range(column) {
+        return createRangeBuilder(getColumnName(column));
+    },
+    hash(column, modulus) {
+        return createHashBuilder(getColumnName(column), modulus);
+    },
+};
+function formatValue(value) {
+    if (value instanceof Date) {
+        return value.toISOString().split('T')[0];
+    }
+    return String(value);
+}
+export function partition(name) {
+    return {
+        $name: name,
+        in(values) {
+            const normalized = Array.isArray(values) ? values : [values];
+            return {
+                $name: name,
+                $partitionType: 'LIST',
+                $values: normalized,
+            };
+        },
+        from(value) {
+            const fromValue = formatValue(value);
+            return {
+                to(toValue) {
+                    return {
+                        $name: name,
+                        $partitionType: 'RANGE',
+                        $from: fromValue,
+                        $to: formatValue(toValue),
+                    };
+                },
+            };
+        },
+        remainder(value) {
+            return {
+                $name: name,
+                $partitionType: 'HASH',
+                $remainder: value,
+            };
+        },
+        default() {
+            return {
+                $name: name,
+                $partitionType: 'DEFAULT',
+                $isDefault: true,
+            };
+        },
+    };
+}
+export function generatePartitionBySQL(strategy) {
+    let sql = `PARTITION BY ${strategy.$type} (${strategy.$column})`;
+    return sql;
+}
+export function generateChildPartitionSQL(parentTable, child, subpartitionStrategy) {
+    let sql = `CREATE TABLE IF NOT EXISTS ${child.$name} PARTITION OF ${parentTable}`;
+    switch (child.$partitionType) {
+        case 'LIST':
+            const values = child.$values?.map(v => `'${v}'`).join(', ') || '';
+            sql += ` FOR VALUES IN (${values})`;
+            break;
+        case 'RANGE':
+            sql += ` FOR VALUES FROM ('${child.$from}') TO ('${child.$to}')`;
+            break;
+        case 'HASH':
+            sql += ` FOR VALUES WITH (MODULUS ${child.$modulus}, REMAINDER ${child.$remainder})`;
+            break;
+        case 'DEFAULT':
+            sql += ` DEFAULT`;
+            break;
+    }
+    if (subpartitionStrategy) {
+        sql += ` ${generatePartitionBySQL(subpartitionStrategy)}`;
+    }
+    return sql + ';';
+}

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

@@ -0,0 +1,70 @@
+export function pgEnum(name, values) {
+    const config = function (columnName) {
+        const col = {
+            $type: name,
+            $enumName: name,
+            $checkValues: values,
+        };
+        if (columnName) {
+            col.$columnName = columnName;
+        }
+        return Object.assign(col, {
+            notNull() {
+                col.$nullable = false;
+                return Object.assign(this, { $nullable: false });
+            },
+            nullable() {
+                col.$nullable = true;
+                return Object.assign(this, { $nullable: true });
+            },
+            default(value) {
+                col.$default = value;
+                return Object.assign(this, { $default: value });
+            },
+            primaryKey() {
+                col.$primaryKey = true;
+                return Object.assign(this, { $primaryKey: true });
+            },
+            unique() {
+                col.$unique = true;
+                return Object.assign(this, { $unique: true });
+            },
+            array() {
+                col.$array = true;
+                col.$type = `${name}[]`;
+                return Object.assign(this, { $array: true, $type: `${name}[]` });
+            },
+        });
+    };
+    Object.defineProperties(config, {
+        $enumName: { value: name, enumerable: true },
+        $enumValues: { value: values, enumerable: true },
+        $inferEnum: { value: undefined },
+        values: { value: values, enumerable: true },
+        name: { value: name, enumerable: true },
+        includes: {
+            value: (value) => {
+                return typeof value === 'string' && values.includes(value);
+            },
+            enumerable: true,
+        },
+    });
+    return config;
+}
+export function generateEnumSQL(name, values) {
+    const escapedValues = values.map(v => `'${v.replace(/'/g, "''")}'`).join(', ');
+    return `CREATE TYPE "${name}" AS ENUM (${escapedValues});`;
+}
+export function dropEnumSQL(name) {
+    return `DROP TYPE IF EXISTS "${name}" CASCADE;`;
+}
+export function addEnumValueSQL(enumName, newValue, position) {
+    let sql = `ALTER TYPE "${enumName}" ADD VALUE '${newValue.replace(/'/g, "''")}'`;
+    if (position?.before) {
+        sql += ` BEFORE '${position.before.replace(/'/g, "''")}'`;
+    }
+    else if (position?.after) {
+        sql += ` AFTER '${position.after.replace(/'/g, "''")}'`;
+    }
+    return sql + ';';
+}

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

@@ -0,0 +1,85 @@
+export function generateFunctionSQL(config) {
+    const { $functionName, $options } = config;
+    const { args = [], returns, language = 'plpgsql', volatility, parallel, security, strict, leakproof, cost, rows, setConfig, body, raw, } = $options;
+    const parts = ['CREATE OR REPLACE FUNCTION', $functionName];
+    const argStrings = args.map(arg => {
+        let argStr = '';
+        if (arg.mode && arg.mode !== 'IN') {
+            argStr += arg.mode + ' ';
+        }
+        argStr += arg.name + ' ' + arg.type;
+        if (arg.default !== undefined) {
+            argStr += ' DEFAULT ' + arg.default;
+        }
+        return argStr;
+    });
+    parts.push('(' + argStrings.join(', ') + ')');
+    parts.push('\nRETURNS ' + returns);
+    parts.push('\nLANGUAGE ' + language);
+    if (volatility) {
+        parts.push('\n' + volatility);
+    }
+    if (parallel) {
+        parts.push('\nPARALLEL ' + parallel);
+    }
+    if (security) {
+        parts.push('\nSECURITY ' + security);
+    }
+    if (strict) {
+        parts.push('\nSTRICT');
+    }
+    if (leakproof) {
+        parts.push('\nLEAKPROOF');
+    }
+    if (cost !== undefined) {
+        parts.push('\nCOST ' + cost);
+    }
+    if (rows !== undefined) {
+        parts.push('\nROWS ' + rows);
+    }
+    if (setConfig) {
+        for (const [key, value] of Object.entries(setConfig)) {
+            parts.push(`\nSET ${key} = '${value}'`);
+        }
+    }
+    parts.push('\nAS $$');
+    if (raw) {
+        parts.push('\n' + raw.trim());
+    }
+    else if (body) {
+        const trimmedBody = body.trim();
+        if (language.toLowerCase() === 'plpgsql' &&
+            !trimmedBody.toUpperCase().startsWith('BEGIN') &&
+            !trimmedBody.toUpperCase().startsWith('DECLARE')) {
+            parts.push('\nBEGIN');
+            parts.push('\n    ' + trimmedBody.replace(/\n/g, '\n    '));
+            parts.push('\nEND;');
+        }
+        else {
+            parts.push('\n' + trimmedBody);
+        }
+    }
+    parts.push('\n$$');
+    return parts.join('');
+}
+export function dropFunctionSQL(config, ifExists = true) {
+    const { $functionName, $options } = config;
+    const argTypes = ($options.args || [])
+        .filter(arg => !arg.mode || arg.mode === 'IN' || arg.mode === 'INOUT' || arg.mode === 'VARIADIC')
+        .map(arg => arg.type)
+        .join(', ');
+    return `DROP FUNCTION ${ifExists ? 'IF EXISTS ' : ''}${$functionName}(${argTypes})`;
+}
+export function pgFunction(name, options) {
+    return {
+        $functionName: name,
+        $options: options,
+        $type: 'function',
+    };
+}
+export function isFunctionConfig(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '$type' in value &&
+        value.$type === 'function');
+}

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

@@ -0,0 +1,50 @@
+export function pgSequence(name, options = {}) {
+    return {
+        _type: 'sequence',
+        name,
+        options,
+    };
+}
+export function generateSequenceSQL(seq) {
+    const parts = [`CREATE SEQUENCE ${seq.name}`];
+    if (seq.options.as) {
+        parts.push(`AS ${seq.options.as.toUpperCase()}`);
+    }
+    if (seq.options.start !== undefined) {
+        parts.push(`START WITH ${seq.options.start}`);
+    }
+    if (seq.options.increment !== undefined) {
+        parts.push(`INCREMENT BY ${seq.options.increment}`);
+    }
+    if (seq.options.minValue === null) {
+        parts.push('NO MINVALUE');
+    }
+    else if (seq.options.minValue !== undefined) {
+        parts.push(`MINVALUE ${seq.options.minValue}`);
+    }
+    if (seq.options.maxValue === null) {
+        parts.push('NO MAXVALUE');
+    }
+    else if (seq.options.maxValue !== undefined) {
+        parts.push(`MAXVALUE ${seq.options.maxValue}`);
+    }
+    if (seq.options.cache !== undefined) {
+        parts.push(`CACHE ${seq.options.cache}`);
+    }
+    if (seq.options.cycle !== undefined) {
+        parts.push(seq.options.cycle ? 'CYCLE' : 'NO CYCLE');
+    }
+    if (seq.options.ownedBy) {
+        parts.push(`OWNED BY ${seq.options.ownedBy}`);
+    }
+    return parts.join('\n    ') + ';';
+}
+export function dropSequenceSQL(seq) {
+    return `DROP SEQUENCE IF EXISTS ${seq.name};`;
+}
+export function isSequenceConfig(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '_type' in value &&
+        value._type === 'sequence');
+}

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

@@ -0,0 +1,102 @@
+function getTableName(table) {
+    if (typeof table === 'string') {
+        return table;
+    }
+    if (typeof table === 'object' && table !== null) {
+        if ('$tableName' in table) {
+            return table.$tableName;
+        }
+        if ('name' in table) {
+            return table.name;
+        }
+    }
+    throw new Error('Invalid table reference in trigger definition');
+}
+function getFunctionName(func) {
+    if (typeof func === 'string') {
+        return func;
+    }
+    return func.$functionName;
+}
+export function generateTriggerSQL(config) {
+    const { $triggerName, $options } = config;
+    const { on, before, after, insteadOf, updateOf, forEachRow = true, forEachStatement, when, referencing, constraint, deferrable, initially, execute, executeArgs, } = $options;
+    const parts = ['CREATE'];
+    if (constraint) {
+        parts.push('CONSTRAINT');
+    }
+    parts.push('TRIGGER', $triggerName);
+    let timing;
+    let events;
+    if (before) {
+        timing = 'BEFORE';
+        events = Array.isArray(before) ? before : [before];
+    }
+    else if (after) {
+        timing = 'AFTER';
+        events = Array.isArray(after) ? after : [after];
+    }
+    else if (insteadOf) {
+        timing = 'INSTEAD OF';
+        events = Array.isArray(insteadOf) ? insteadOf : [insteadOf];
+    }
+    else {
+        throw new Error('Trigger must have before, after, or insteadOf timing');
+    }
+    parts.push('\n    ' + timing);
+    const eventStrings = events.map(event => {
+        if (event === 'UPDATE' && updateOf && updateOf.length > 0) {
+            return 'UPDATE OF ' + updateOf.join(', ');
+        }
+        return event;
+    });
+    parts.push(eventStrings.join(' OR '));
+    parts.push('ON', getTableName(on));
+    if (deferrable) {
+        parts.push('\n    DEFERRABLE');
+        if (initially) {
+            parts.push('INITIALLY', initially);
+        }
+    }
+    if (referencing) {
+        const refParts = ['\n    REFERENCING'];
+        if (referencing.oldTable) {
+            refParts.push('OLD TABLE AS', referencing.oldTable);
+        }
+        if (referencing.newTable) {
+            refParts.push('NEW TABLE AS', referencing.newTable);
+        }
+        parts.push(refParts.join(' '));
+    }
+    if (forEachStatement) {
+        parts.push('\n    FOR EACH STATEMENT');
+    }
+    else if (forEachRow !== false) {
+        parts.push('\n    FOR EACH ROW');
+    }
+    if (when) {
+        parts.push('\n    WHEN (' + when + ')');
+    }
+    const funcName = getFunctionName(execute);
+    const args = executeArgs ? executeArgs.join(', ') : '';
+    parts.push('\n    EXECUTE FUNCTION', funcName + '(' + args + ')');
+    return parts.join(' ');
+}
+export function dropTriggerSQL(config, ifExists = true) {
+    const { $triggerName, $options } = config;
+    const tableName = getTableName($options.on);
+    return `DROP TRIGGER ${ifExists ? 'IF EXISTS ' : ''}${$triggerName} ON ${tableName}`;
+}
+export function pgTrigger(name, options) {
+    return {
+        $triggerName: name,
+        $options: options,
+        $type: 'trigger',
+    };
+}
+export function isTriggerConfig(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '$type' in value &&
+        value.$type === 'trigger');
+}

package/dist/esm/schema-definition/relations.js

@@ -0,0 +1,90 @@
+export function one(from, to, options) {
+    const foreignKey = options?.foreignKey || `${to.$name}_id`;
+    const references = options?.references || findPrimaryKey(to) || 'id';
+    return {
+        $type: 'one',
+        $from: from,
+        $to: to,
+        $foreignKey: foreignKey,
+        $references: references,
+    };
+}
+export function many(from, to, options) {
+    const foreignKey = options?.foreignKey || `${from.$name}_id`;
+    const references = options?.references || findPrimaryKey(from) || 'id';
+    return {
+        $type: 'many',
+        $from: from,
+        $to: to,
+        $foreignKey: foreignKey,
+        $references: references,
+    };
+}
+export function manyToMany(from, to, through, options) {
+    const fromKey = options?.fromKey || findPrimaryKey(from) || 'id';
+    const toKey = options?.toKey || findPrimaryKey(to) || 'id';
+    const throughFromKey = options?.throughFromKey || `${from.$name}_id`;
+    const throughToKey = options?.throughToKey || `${to.$name}_id`;
+    return {
+        $type: 'manyToMany',
+        $from: from,
+        $to: to,
+        $foreignKey: fromKey,
+        $references: toKey,
+        $through: through,
+        $throughFromKey: throughFromKey,
+        $throughToKey: throughToKey,
+    };
+}
+function findPrimaryKey(table) {
+    if (table.$primaryKey && table.$primaryKey.length === 1) {
+        return table.$primaryKey[0];
+    }
+    for (const [colName, colConfig] of Object.entries(table.$columns)) {
+        if (colConfig.$primaryKey) {
+            return colName;
+        }
+    }
+    return undefined;
+}
+export function defineRelations(config) {
+    return {
+        tables: config.tables,
+        relations: config.relations(config.tables),
+    };
+}
+export function getJoinCondition(relation) {
+    if (relation.$type === 'manyToMany' && relation.$through) {
+        return {
+            type: 'manyToMany',
+            from: { table: relation.$from.$name, column: relation.$foreignKey },
+            to: { table: relation.$to.$name, column: relation.$references },
+            through: {
+                table: relation.$through.$name,
+                fromColumn: relation.$throughFromKey,
+                toColumn: relation.$throughToKey,
+            },
+        };
+    }
+    return {
+        type: relation.$type,
+        from: { table: relation.$from.$name, column: relation.$foreignKey },
+        to: { table: relation.$to.$name, column: relation.$references },
+    };
+}
+export function generateJoinSQL(relation, fromAlias, toAlias) {
+    const from = fromAlias || relation.$from.$name;
+    const to = toAlias || relation.$to.$name;
+    if (relation.$type === 'manyToMany' && relation.$through) {
+        const throughTable = relation.$through.$name;
+        const throughAlias = `${throughTable}_join`;
+        return [
+            `JOIN "${throughTable}" AS "${throughAlias}" ON "${from}"."${relation.$foreignKey}" = "${throughAlias}"."${relation.$throughFromKey}"`,
+            `JOIN "${relation.$to.$name}" AS "${to}" ON "${throughAlias}"."${relation.$throughToKey}" = "${to}"."${relation.$references}"`,
+        ].join('\n');
+    }
+    if (relation.$type === 'one') {
+        return `JOIN "${relation.$to.$name}" AS "${to}" ON "${from}"."${relation.$foreignKey}" = "${to}"."${relation.$references}"`;
+    }
+    return `JOIN "${relation.$to.$name}" AS "${to}" ON "${to}"."${relation.$foreignKey}" = "${from}"."${relation.$references}"`;
+}