relq 1.0.5 → 1.0.6

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

@@ -0,0 +1,161 @@
+function createColumnRef(tableName, columnName, schemaKey) {
+    return {
+        $table: tableName,
+        $column: columnName,
+        $schemaKey: schemaKey,
+    };
+}
+function createTargetColumnRefs(schemaKey, table) {
+    const refs = {};
+    const actualTableName = table.$name;
+    for (const colName of Object.keys(table.$columns)) {
+        const colDef = table.$columns[colName];
+        const actualColName = colDef.$sqlName || colName;
+        refs[colName] = createColumnRef(actualTableName, actualColName, colName);
+    }
+    return refs;
+}
+function createReferenceToBuilder(schema, currentTableKey) {
+    return new Proxy({}, {
+        get(_, targetTableKey) {
+            const targetTable = schema[targetTableKey];
+            if (!targetTable) {
+                throw new Error(`Unknown table: ${targetTableKey}`);
+            }
+            return (callback) => {
+                const targetColRefs = createTargetColumnRefs(targetTableKey, targetTable);
+                const options = callback(targetColRefs);
+                const currentTable = schema[currentTableKey];
+                const currentTableName = currentTable?.$name || currentTableKey;
+                if ('columns' in options && Array.isArray(options.columns)) {
+                    const compositeOpts = options;
+                    return {
+                        $type: 'foreignKey',
+                        $targetTable: targetTable.$name,
+                        $columns: compositeOpts.columns.map(c => ({
+                            table: c.$table,
+                            column: c.$column,
+                        })),
+                        $references: compositeOpts.references.map(r => ({
+                            table: r.$table,
+                            column: r.$column,
+                        })),
+                        $onDelete: compositeOpts.onDelete,
+                        $onUpdate: compositeOpts.onUpdate,
+                        $match: compositeOpts.match,
+                        $deferrable: compositeOpts.deferrable,
+                        $initiallyDeferred: compositeOpts.initiallyDeferred,
+                    };
+                }
+                const singleOpts = options;
+                const referencesCol = singleOpts.references;
+                return {
+                    $type: 'foreignKey',
+                    $targetTable: targetTable.$name,
+                    $columns: [],
+                    $references: referencesCol ? [{
+                            table: referencesCol.$table,
+                            column: referencesCol.$column,
+                        }] : undefined,
+                    $onDelete: singleOpts.onDelete,
+                    $onUpdate: singleOpts.onUpdate,
+                    $match: singleOpts.match,
+                    $deferrable: singleOpts.deferrable,
+                    $initiallyDeferred: singleOpts.initiallyDeferred,
+                };
+            };
+        },
+    });
+}
+function createSourceColumnRefs(schemaKey, table) {
+    const refs = {};
+    const actualTableName = table.$name;
+    for (const colName of Object.keys(table.$columns)) {
+        const colDef = table.$columns[colName];
+        const actualColName = colDef.$sqlName || colName;
+        refs[colName] = createColumnRef(actualTableName, actualColName, colName);
+    }
+    return refs;
+}
+function createFullBuilder(schema, currentTableKey) {
+    const builder = {
+        referenceTo: createReferenceToBuilder(schema, currentTableKey),
+    };
+    for (const [tableName, table] of Object.entries(schema)) {
+        builder[tableName] = createSourceColumnRefs(tableName, table);
+    }
+    return builder;
+}
+export function pgRelations(schema, builder) {
+    const tables = {};
+    for (const tableKey of Object.keys(schema)) {
+        tables[tableKey] = (defineRelations) => {
+            const fullBuilder = createFullBuilder(schema, tableKey);
+            return defineRelations(fullBuilder);
+        };
+    }
+    return builder(tables);
+}
+export function defineRelations(schema, relationDefs) {
+    const result = {};
+    for (const [tableKey, defFn] of Object.entries(relationDefs)) {
+        if (typeof defFn === 'function') {
+            const fullBuilder = createFullBuilder(schema, tableKey);
+            result[tableKey] = defFn(fullBuilder);
+        }
+    }
+    return result;
+}
+export function actionCodeToString(code) {
+    switch (code) {
+        case 'a': return 'NO ACTION';
+        case 'r': return 'RESTRICT';
+        case 'c': return 'CASCADE';
+        case 'n': return 'SET NULL';
+        case 'd': return 'SET DEFAULT';
+        default: return 'NO ACTION';
+    }
+}
+export function stringToActionCode(action) {
+    switch (action) {
+        case 'NO ACTION': return 'a';
+        case 'RESTRICT': return 'r';
+        case 'CASCADE': return 'c';
+        case 'SET NULL': return 'n';
+        case 'SET DEFAULT': return 'd';
+        default: return 'a';
+    }
+}
+export function matchCodeToString(code) {
+    switch (code) {
+        case 'f': return 'FULL';
+        case 's':
+        default: return 'SIMPLE';
+    }
+}
+export function generateReferencesSQL(relation, columnName, columnType = 'uuid') {
+    const parts = [`${columnName} ${columnType}`];
+    if (relation.$references && relation.$references.length > 0) {
+        const refCols = relation.$references.map(r => r.column).join(', ');
+        parts.push(`REFERENCES ${relation.$targetTable}(${refCols})`);
+    }
+    else {
+        parts.push(`REFERENCES ${relation.$targetTable}`);
+    }
+    if (relation.$onDelete && relation.$onDelete !== 'NO ACTION') {
+        parts.push(`ON DELETE ${relation.$onDelete}`);
+    }
+    if (relation.$onUpdate && relation.$onUpdate !== 'NO ACTION') {
+        parts.push(`ON UPDATE ${relation.$onUpdate}`);
+    }
+    if (relation.$match && relation.$match !== 'SIMPLE') {
+        parts.push(`MATCH ${relation.$match}`);
+    }
+    if (relation.$deferrable) {
+        parts.push('DEFERRABLE');
+        if (relation.$initiallyDeferred) {
+            parts.push('INITIALLY DEFERRED');
+        }
+    }
+    return parts.join(' ');
+}

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

@@ -0,0 +1,24 @@
+export function pgView(name, definition) {
+    return {
+        _type: 'view',
+        name,
+        definition: definition.trim(),
+        isMaterialized: false,
+    };
+}
+export function pgMaterializedView(name, definition, options) {
+    return {
+        _type: 'materialized_view',
+        name,
+        definition: definition.trim(),
+        isMaterialized: true,
+        withData: options?.withData,
+    };
+}
+export function viewToSQL(view) {
+    return `CREATE OR REPLACE VIEW "${view.name}" AS\n${view.definition};`;
+}
+export function materializedViewToSQL(view) {
+    const withData = view.withData !== false ? ' WITH DATA' : ' WITH NO DATA';
+    return `CREATE MATERIALIZED VIEW IF NOT EXISTS "${view.name}" AS\n${view.definition}${withData};`;
+}

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

@@ -37,6 +37,9 @@ function createColumnExpr(colName) {
         neq(value) {
             return whereCondition(`${this.$sql} != ${formatWhereValue(value)}`);
         },
+        ne(value) {
+            return whereCondition(`${this.$sql} <> ${formatWhereValue(value)}`);
+        },
         gt(value) {
             return whereCondition(`${this.$sql} > ${formatWhereValue(value)}`);
         },
@@ -171,6 +174,9 @@ function createCheckExpr(sql) {
         neq(value) {
             return createCheckWhereCondition(`${this.$sql} != ${formatVal(value)}`);
         },
+        ne(value) {
+            return createCheckWhereCondition(`${this.$sql} <> ${formatVal(value)}`);
+        },
         isNull() {
             return createCheckWhereCondition(`${this.$sql} IS NULL`);
         },
@@ -255,6 +261,53 @@ function createCheckConstraintBuilder() {
         constraint(name, condition) {
             return { name, expression: condition.$sql };
         },
+        raw(expression) {
+            return createCheckWhereCondition(expression);
+        },
+    };
+}
+function createConstraintBuilder() {
+    return {
+        primaryKey(...args) {
+            if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && 'columns' in args[0]) {
+                const opts = args[0];
+                return {
+                    $type: 'PRIMARY KEY',
+                    $name: opts.name || '',
+                    $columns: opts.columns.map(c => String(c)),
+                };
+            }
+            const columns = args;
+            return {
+                $type: 'PRIMARY KEY',
+                $name: '',
+                $columns: columns.map(c => String(c)),
+            };
+        },
+        unique(...args) {
+            if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && 'columns' in args[0]) {
+                const opts = args[0];
+                return {
+                    $type: 'UNIQUE',
+                    $name: opts.name || '',
+                    $columns: opts.columns.map(c => String(c)),
+                };
+            }
+            const columns = args;
+            return {
+                $type: 'UNIQUE',
+                $name: '',
+                $columns: columns.map(c => String(c)),
+            };
+        },
+        exclude(name, expression) {
+            return {
+                $type: 'EXCLUDE',
+                $name: name,
+                $columns: [],
+                $expression: expression,
+            };
+        },
     };
 }
 function createColumnRefs(columns) {
@@ -266,6 +319,15 @@ function createColumnRefs(columns) {
     }
     return refs;
 }
+function createIndexTableRefs(columns) {
+    const refs = {};
+    for (const key of Object.keys(columns)) {
+        const col = columns[key];
+        const colName = col.$columnName || key;
+        refs[key] = createColumnExpr(colName);
+    }
+    return refs;
+}
 function createIndexFactory() {
     const factory = (name) => {
         const def = {
@@ -325,6 +387,22 @@ function createIndexFactory() {
                 def._opclass = opclass;
                 return Object.assign(this, { _opclass: opclass });
             },
+            ifNotExists() {
+                def.ifNotExists = true;
+                return Object.assign(this, { ifNotExists: true });
+            },
+            tableOnly() {
+                def.tableOnly = true;
+                return Object.assign(this, { tableOnly: true });
+            },
+            comment(text) {
+                def.comment = text;
+                return Object.assign(this, { comment: text });
+            },
+            $id(trackingId) {
+                def.trackingId = trackingId;
+                return Object.assign(this, { trackingId: trackingId });
+            },
         };
         return {
             on(...columns) {
@@ -348,10 +426,11 @@ function createIndexFactory() {
 const indexFactory = createIndexFactory();
 export function defineTable(name, columns, options) {
     const columnRefs = createColumnRefs(columns);
+    const indexTableRefs = createIndexTableRefs(columns);
     let resolvedIndexes;
     if (options?.indexes) {
         if (typeof options.indexes === 'function') {
-            const rawIndexes = options.indexes(columnRefs, indexFactory, sqlFunctions);
+            const rawIndexes = options.indexes(indexTableRefs, indexFactory, sqlFunctions);
             resolvedIndexes = rawIndexes.map(normalizeIndexDef);
         }
         else {
@@ -369,6 +448,11 @@ export function defineTable(name, columns, options) {
         const constraints = options.checkConstraints(checkTableRefs, checkBuilder);
         resolvedCheckConstraints = constraints.map(c => ({ expression: c.expression, name: c.name }));
     }
+    let resolvedConstraints;
+    if (options?.constraints) {
+        const constraintBuilder = createConstraintBuilder();
+        resolvedConstraints = options.constraints(columnRefs, constraintBuilder);
+    }
     const definition = {
         $name: name,
         $schema: options?.schema,
@@ -376,12 +460,14 @@ export function defineTable(name, columns, options) {
         $primaryKey: options?.primaryKey,
         $uniqueConstraints: options?.uniqueConstraints,
         $checkConstraints: resolvedCheckConstraints,
+        $constraints: resolvedConstraints,
         $foreignKeys: options?.foreignKeys,
         $indexes: resolvedIndexes,
         $inherits: options?.inherits,
         $partitionBy: resolvedPartitionBy,
         $tablespace: options?.tablespace,
         $withOptions: options?.withOptions,
+        $ifNotExists: options?.ifNotExists,
         $inferSelect: {},
         $inferInsert: {},
         toSQL() {
@@ -410,13 +496,16 @@ function normalizeIndexDef(idx) {
         nulls: idx.nulls,
         order: idx.order,
         include: idx.include,
+        ifNotExists: idx.ifNotExists,
+        tableOnly: idx.tableOnly,
     };
 }
 function generateCreateTableSQL(def) {
     const tableName = def.$schema
         ? `${format.ident(def.$schema)}.${format.ident(def.$name)}`
         : format.ident(def.$name);
-    const parts = [`CREATE TABLE ${tableName} (`];
+    const ifNotExistsClause = def.$ifNotExists ? 'IF NOT EXISTS ' : '';
+    const parts = [`CREATE TABLE ${ifNotExistsClause}${tableName} (`];
     const columnDefs = [];
     const constraints = [];
     for (const [colName, colConfig] of Object.entries(def.$columns)) {
@@ -450,6 +539,12 @@ function generateCreateTableSQL(def) {
             }
         }
     }
+    if (def.$constraints) {
+        for (const c of def.$constraints) {
+            const cols = c.$columns.map(col => format.ident(col)).join(', ');
+            constraints.push(`CONSTRAINT ${format.ident(c.$name)} ${c.$type} (${cols})`);
+        }
+    }
     if (def.$foreignKeys) {
         for (const fk of def.$foreignKeys) {
             const cols = fk.columns.map(c => format.ident(c)).join(', ');
@@ -511,7 +606,10 @@ function generateColumnSQL(name, config) {
         const defaultVal = typeof config.$default === 'function'
             ? config.$default()
             : config.$default;
-        if (typeof defaultVal === 'symbol') {
+        if (typeof defaultVal === 'object' && defaultVal !== null && '$isDefault' in defaultVal && '$sql' in defaultVal) {
+            parts.push(`DEFAULT ${defaultVal.$sql}`);
+        }
+        else if (typeof defaultVal === 'symbol') {
             const symDesc = defaultVal.description || String(defaultVal);
             if (symDesc.includes('emptyObject')) {
                 parts.push(`DEFAULT '{}'::jsonb`);
@@ -587,7 +685,15 @@ function generateIndexSQL(def) {
         if (idx.unique) {
             sql += ' UNIQUE';
         }
-        sql += ` INDEX ${format.ident(indexName)} ON ${tableName}`;
+        sql += ' INDEX';
+        if (idx.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${format.ident(indexName)} ON`;
+        if (idx.tableOnly) {
+            sql += ' ONLY';
+        }
+        sql += ` ${tableName}`;
         if (idx.using) {
             sql += ` USING ${idx.using}`;
         }

package/dist/esm/types/config-types.js

@@ -6,18 +6,23 @@ export function toPoolConfig(config) {
     const smartDefaults = config.disableSmartDefaults
         ? { min: 0, max: 10, idleTimeoutMillis: 30000, connectionTimeoutMillis: 0 }
         : mergeWithDefaults(config.pool);
+    const isAws = !!config.aws;
+    const host = isAws ? config.aws.hostname : (config.host || 'localhost');
+    const port = config.aws?.port ?? config.port ?? 5432;
+    const user = config.aws?.user ?? config.user ?? (isAws ? 'admin' : undefined);
+    const ssl = isAws ? (config.aws.ssl ?? true) : config.ssl;
     const poolConfig = {
-        host: config.host || 'localhost',
-        port: config.port || 5432,
+        host,
+        port,
         database: config.database,
-        user: config.user,
+        user,
         password: config.password,
         min: config.pool?.min ?? smartDefaults.min,
         max: config.pool?.max ?? smartDefaults.max,
         idleTimeoutMillis: config.pool?.idleTimeoutMillis ?? smartDefaults.idleTimeoutMillis,
         connectionTimeoutMillis: config.pool?.connectionTimeoutMillis ?? smartDefaults.connectionTimeoutMillis,
         application_name: config.pool?.application_name,
-        ssl: config.pool?.ssl,
+        ssl: config.pool?.ssl ?? ssl,
         allowExitOnIdle: true
     };
     if (config.connectionString) {
@@ -34,3 +39,6 @@ export function toPoolConfig(config) {
     }
     return poolConfig;
 }
+export function isAwsDsqlConfig(config) {
+    return !!config.aws?.hostname && !!config.aws?.region;
+}

package/dist/esm/utils/aws-dsql.js

@@ -0,0 +1,139 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, accessSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { F_OK, W_OK, R_OK } from 'node:constants';
+import { RelqConfigError } from "../errors/relq-errors.js";
+const tokenCache = new Map();
+function getCacheKey(config) {
+    const hash = createHash('md5')
+        .update(`${config.secretAccessKey ?? ''}-${config.accessKeyId ?? ''}-${config.region}-${config.hostname}`)
+        .digest('hex');
+    return hash;
+}
+function getTempFolder() {
+    return join(tmpdir(), '.dsql_');
+}
+function isTempFolderAvailable() {
+    const tempFolder = getTempFolder();
+    try {
+        mkdirSync(tempFolder, { recursive: true });
+        accessSync(tempFolder, F_OK | R_OK | W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getFromCache(cacheKey) {
+    const memoryToken = tokenCache.get(cacheKey);
+    if (memoryToken && memoryToken.expiresAt > Date.now()) {
+        return memoryToken;
+    }
+    const envName = `DSQL_TOKEN_${cacheKey}`;
+    const envToken = process.env[envName];
+    if (envToken) {
+        try {
+            const parsed = JSON.parse(envToken);
+            if (parsed.expiresAt > Date.now()) {
+                tokenCache.set(cacheKey, parsed);
+                return parsed;
+            }
+        }
+        catch { }
+    }
+    if (isTempFolderAvailable()) {
+        const tokenFile = join(getTempFolder(), `${cacheKey}.json`);
+        if (existsSync(tokenFile)) {
+            try {
+                const parsed = JSON.parse(readFileSync(tokenFile, 'utf8'));
+                if (parsed.expiresAt > Date.now()) {
+                    tokenCache.set(cacheKey, parsed);
+                    process.env[envName] = JSON.stringify(parsed);
+                    return parsed;
+                }
+            }
+            catch { }
+        }
+    }
+    return null;
+}
+function saveToCache(cacheKey, token) {
+    tokenCache.set(cacheKey, token);
+    const envName = `DSQL_TOKEN_${cacheKey}`;
+    process.env[envName] = JSON.stringify(token);
+    if (isTempFolderAvailable()) {
+        const tokenFile = join(getTempFolder(), `${cacheKey}.json`);
+        try {
+            writeFileSync(tokenFile, JSON.stringify(token));
+        }
+        catch { }
+    }
+}
+let DsqlSigner = null;
+async function loadAwsSdk() {
+    if (!DsqlSigner) {
+        try {
+            const sdk = await import('@aws-sdk/dsql-signer');
+            DsqlSigner = sdk.DsqlSigner;
+        }
+        catch (error) {
+            throw new RelqConfigError('AWS DSQL requires @aws-sdk/dsql-signer package.\n\n' +
+                'Install it with:\n' +
+                '  npm install @aws-sdk/dsql-signer\n' +
+                '  # or\n' +
+                '  bun add @aws-sdk/dsql-signer', { field: '@aws-sdk/dsql-signer', value: 'not installed' });
+        }
+    }
+    return DsqlSigner;
+}
+export async function getAwsDsqlToken(config) {
+    const cacheKey = getCacheKey(config);
+    const cached = getFromCache(cacheKey);
+    if (cached) {
+        return cached.token;
+    }
+    if (!config.useDefaultCredentials && (!config.accessKeyId || !config.secretAccessKey)) {
+        throw new RelqConfigError('AWS DSQL requires credentials. Either provide accessKeyId + secretAccessKey, ' +
+            'or set useDefaultCredentials: true to use AWS credential chain.', { field: 'aws.credentials', value: 'missing' });
+    }
+    const SignerClass = await loadAwsSdk();
+    const expiresIn = config.tokenExpiresIn ?? 604800;
+    const signerConfig = {
+        hostname: config.hostname,
+        region: config.region,
+        expiresIn,
+    };
+    if (!config.useDefaultCredentials) {
+        signerConfig.credentials = {
+            accessKeyId: config.accessKeyId,
+            secretAccessKey: config.secretAccessKey,
+        };
+    }
+    const signer = new SignerClass(signerConfig);
+    const token = await signer.getDbConnectAdminAuthToken();
+    const cachedToken = {
+        token,
+        expiresAt: Date.now() + ((expiresIn - 30) * 1000)
+    };
+    saveToCache(cacheKey, cachedToken);
+    return token;
+}
+export function clearAwsDsqlToken(config) {
+    const cacheKey = getCacheKey(config);
+    tokenCache.delete(cacheKey);
+    const envName = `DSQL_TOKEN_${cacheKey}`;
+    delete process.env[envName];
+    if (isTempFolderAvailable()) {
+        const tokenFile = join(getTempFolder(), `${cacheKey}.json`);
+        try {
+            if (existsSync(tokenFile)) {
+                writeFileSync(tokenFile, '');
+            }
+        }
+        catch { }
+    }
+}
+export function isAwsDsql(config) {
+    return !!config.aws?.hostname && !!config.aws?.region;
+}