@relq/orm 0.1.0

package/dist/esm/select/select-builder.js

@@ -0,0 +1,419 @@
+import format from "../shared/pg-format.js";
+import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
+export class SelectBuilder {
+    tableName;
+    tableAlias;
+    selectColumns = ['*'];
+    whereConditions = [];
+    havingConditions = [];
+    joinClauses = [];
+    structuredJoins = [];
+    groupByColumns = [];
+    orderByColumns = [];
+    limitValue;
+    offsetValue;
+    distinctOnColumns = [];
+    isDistinct = false;
+    lockingClause;
+    unionQueries = [];
+    includeExpressions = [];
+    columnResolver;
+    constructor(tableName, columns) {
+        this.tableName = tableName;
+        if (columns) {
+            this.selectColumns = Array.isArray(columns) ? columns : [columns];
+        }
+    }
+    setColumnResolver(resolver) {
+        this.columnResolver = resolver;
+        return this;
+    }
+    transformConditionColumns(conditions) {
+        if (!this.columnResolver) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditionColumns(cond.values)
+                };
+            }
+            if (!cond.column) {
+                return cond;
+            }
+            if (cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.column.includes('.')) {
+                const [tableRef, colName] = cond.column.split('.');
+                return {
+                    ...cond,
+                    column: `${tableRef}.${this.columnResolver(colName)}`
+                };
+            }
+            return {
+                ...cond,
+                column: this.columnResolver(cond.column)
+            };
+        });
+    }
+    setTableAlias(alias) {
+        this.tableAlias = alias;
+        return this;
+    }
+    getTableIdentifier() {
+        return this.tableAlias || this.tableName;
+    }
+    distinct() {
+        this.isDistinct = true;
+        return this;
+    }
+    where(callback) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    join(table, condition) {
+        this.joinClauses.push(`JOIN ${format.ident(table)} ON ${condition}`);
+        return this;
+    }
+    leftJoin(table, condition) {
+        this.joinClauses.push(`LEFT JOIN ${format.ident(table)} ON ${condition}`);
+        return this;
+    }
+    rightJoin(table, condition) {
+        this.joinClauses.push(`RIGHT JOIN ${format.ident(table)} ON ${condition}`);
+        return this;
+    }
+    innerJoin(table, condition) {
+        this.joinClauses.push(`INNER JOIN ${format.ident(table)} ON ${condition}`);
+        return this;
+    }
+    addRawJoin(joinSQL) {
+        this.joinClauses.push(joinSQL);
+        return this;
+    }
+    groupBy(...columns) {
+        this.groupByColumns.push(...columns);
+        return this;
+    }
+    having(callback) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        this.havingConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByColumns.push({ column, direction });
+        return this;
+    }
+    orderByNulls(column, direction, nulls) {
+        this.orderByColumns.push({ column, direction, nulls });
+        return this;
+    }
+    orderAsc(column) {
+        return this.orderBy(column, 'ASC');
+    }
+    orderDesc(column) {
+        return this.orderBy(column, 'DESC');
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    distinctOn(...columns) {
+        this.distinctOnColumns.push(...columns);
+        return this;
+    }
+    forUpdate() {
+        this.lockingClause = 'FOR UPDATE';
+        return this;
+    }
+    forUpdateNoWait() {
+        this.lockingClause = 'FOR UPDATE NOWAIT';
+        return this;
+    }
+    forUpdateSkipLocked() {
+        this.lockingClause = 'FOR UPDATE SKIP LOCKED';
+        return this;
+    }
+    forShare() {
+        this.lockingClause = 'FOR SHARE';
+        return this;
+    }
+    forShareNoWait() {
+        this.lockingClause = 'FOR SHARE NOWAIT';
+        return this;
+    }
+    forShareSkipLocked() {
+        this.lockingClause = 'FOR SHARE SKIP LOCKED';
+        return this;
+    }
+    union(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'UNION'
+        });
+        return this;
+    }
+    unionAll(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'UNION ALL'
+        });
+        return this;
+    }
+    intersect(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'INTERSECT'
+        });
+        return this;
+    }
+    except(query) {
+        this.unionQueries.push({
+            query: typeof query === 'string' ? query : query.toString(),
+            type: 'EXCEPT'
+        });
+        return this;
+    }
+    fullOuterJoin(table, condition) {
+        this.joinClauses.push(`FULL OUTER JOIN ${format.ident(table)} ON ${condition}`);
+        return this;
+    }
+    crossJoin(table) {
+        this.joinClauses.push(`CROSS JOIN ${format.ident(table)}`);
+        return this;
+    }
+    lateralJoin(subquery, left = false) {
+        const joinType = left ? 'LEFT JOIN LATERAL' : 'JOIN LATERAL';
+        this.joinClauses.push(`${joinType} ${subquery}`);
+        return this;
+    }
+    addStructuredJoin(join) {
+        this.structuredJoins.push(join);
+        return this;
+    }
+    getStructuredJoins() {
+        return [...this.structuredJoins];
+    }
+    addIncludeExpression(alias, sql) {
+        this.includeExpressions.push({ alias, sql });
+        return this;
+    }
+    qualifyWhereConditions(conditions, tableRef) {
+        return conditions.map(cond => {
+            if (!cond.column) {
+                return cond;
+            }
+            if (cond.column.includes('.')) {
+                return cond;
+            }
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.qualifyWhereConditions(cond.values, tableRef)
+                };
+            }
+            return {
+                ...cond,
+                column: `${tableRef}.${cond.column}`
+            };
+        });
+    }
+    buildStructuredJoinSQL(join) {
+        if ((join.type === 'LEFT JOIN LATERAL' || join.type === 'JOIN LATERAL') && join.lateralSubquery) {
+            return `${join.type} ${join.lateralSubquery} ON true`;
+        }
+        if (join.type === 'CROSS JOIN') {
+            const tableRef = join.alias !== join.table
+                ? `${format.ident(join.table)} AS ${format.ident(join.alias)}`
+                : format.ident(join.table);
+            return `CROSS JOIN ${tableRef}`;
+        }
+        const tableRef = join.alias !== join.table
+            ? `${format.ident(join.table)} AS ${format.ident(join.alias)}`
+            : format.ident(join.table);
+        if (join.usingColumns && join.usingColumns.length > 0) {
+            const usingSQL = join.usingColumns.map(c => format.ident(c)).join(', ');
+            return `${join.type} ${tableRef} USING (${usingSQL})`;
+        }
+        if (join.onClause) {
+            return `${join.type} ${tableRef} ON ${join.onClause}`;
+        }
+        return `${join.type} ${tableRef}`;
+    }
+    toString() {
+        const hasJoins = this.joinClauses.length > 0 || this.structuredJoins.length > 0;
+        const tableRef = this.tableAlias || this.tableName;
+        const columns = this.selectColumns.map(col => {
+            if (col === '*') {
+                return hasJoins ? `${format.ident(tableRef)}.*` : '*';
+            }
+            if (Array.isArray(col)) {
+                const [column, alias] = col;
+                if (hasJoins) {
+                    return format('%I.%I AS %I', tableRef, column, alias);
+                }
+                return format('%I AS %I', column, alias);
+            }
+            if (col.includes('(') || col.includes('DISTINCT') || col.includes(' AS ') || col.includes('.')) {
+                return col;
+            }
+            if (hasJoins) {
+                return format('%I.%I', tableRef, col);
+            }
+            return format.ident(col);
+        });
+        for (const join of this.structuredJoins) {
+            if (join.type === 'LEFT JOIN LATERAL' || join.type === 'JOIN LATERAL') {
+                columns.push(`${format.ident(join.alias + '_lateral')}.${format.ident(join.alias)} AS ${format.ident(join.alias)}`);
+            }
+            else if (join.selectColumns && join.selectColumns.length > 0) {
+                const jsonArgs = join.selectColumns
+                    .map(col => `'${col.property}', ${format.ident(join.alias)}.${format.ident(col.sqlName)}`)
+                    .join(', ');
+                columns.push(`json_build_object(${jsonArgs}) AS ${format.ident(join.alias)}`);
+            }
+            else {
+                columns.push(`row_to_json(${format.ident(join.alias)}.*) AS ${format.ident(join.alias)}`);
+            }
+        }
+        for (const expr of this.includeExpressions) {
+            columns.push(`${expr.sql} AS ${format.ident(expr.alias)}`);
+        }
+        const columnsSQL = columns.join(', ');
+        let query = 'SELECT';
+        if (this.distinctOnColumns.length > 0) {
+            const distinctCols = this.distinctOnColumns.map(col => format.ident(col)).join(', ');
+            query += format(' DISTINCT ON (%s)', distinctCols);
+        }
+        else if (this.isDistinct) {
+            query += ' DISTINCT';
+        }
+        if (this.tableAlias && this.tableAlias !== this.tableName) {
+            query += format(' %s FROM %I AS %I', columnsSQL, this.tableName, this.tableAlias);
+        }
+        else {
+            query += format(' %s FROM %I', columnsSQL, this.tableName);
+        }
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.structuredJoins.length > 0) {
+            const structuredJoinSQL = this.structuredJoins
+                .map(join => this.buildStructuredJoinSQL(join))
+                .join(' ');
+            query += ' ' + structuredJoinSQL;
+        }
+        if (this.whereConditions.length > 0) {
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
+            query += ' WHERE ' + buildConditionsSQL(conditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            const groupBySQL = this.groupByColumns.map(col => {
+                if (col.includes('.'))
+                    return col;
+                if (hasJoins)
+                    return format('%I.%I', tableRef, col);
+                return format.ident(col);
+            }).join(', ');
+            query += ' GROUP BY ' + groupBySQL;
+        }
+        if (this.havingConditions.length > 0) {
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
+            query += ' HAVING ' + buildConditionsSQL(havingConds);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(order => {
+                let sql = format('%I %s', order.column, order.direction);
+                if (order.nulls) {
+                    sql += ` NULLS ${order.nulls}`;
+                }
+                return sql;
+            })
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += format(' LIMIT %s', this.limitValue);
+        }
+        if (this.offsetValue !== undefined) {
+            query += format(' OFFSET %s', this.offsetValue);
+        }
+        if (this.lockingClause) {
+            query += ' ' + this.lockingClause;
+        }
+        if (this.unionQueries.length > 0) {
+            for (const unionQuery of this.unionQueries) {
+                query += ` ${unionQuery.type} ${unionQuery.query}`;
+            }
+        }
+        return query;
+    }
+    whereRaw(condition) {
+        this.whereConditions.push({
+            method: 'raw',
+            column: condition,
+            values: undefined
+        });
+        return this;
+    }
+    toCountSQL() {
+        let query;
+        const hasJoins = this.joinClauses.length > 0 || this.structuredJoins.length > 0;
+        const tableRef = this.tableAlias || this.tableName;
+        if (this.tableAlias && this.tableAlias !== this.tableName) {
+            query = `SELECT COUNT(*) as count FROM ${format.ident(this.tableName)} AS ${format.ident(this.tableAlias)}`;
+        }
+        else {
+            query = `SELECT COUNT(*) as count FROM ${format.ident(this.tableName)}`;
+        }
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.structuredJoins.length > 0) {
+            const structuredJoinSQL = this.structuredJoins
+                .map(join => this.buildStructuredJoinSQL(join))
+                .join(' ');
+            query += ' ' + structuredJoinSQL;
+        }
+        if (this.whereConditions.length > 0) {
+            let conditions = this.transformConditionColumns(this.whereConditions);
+            if (hasJoins) {
+                conditions = this.qualifyWhereConditions(conditions, tableRef);
+            }
+            query += ' WHERE ' + buildConditionsSQL(conditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            const groupBySQL = this.groupByColumns.map(col => {
+                if (col.includes('.'))
+                    return col;
+                if (hasJoins)
+                    return format('%I.%I', tableRef, col);
+                return format.ident(col);
+            }).join(', ');
+            query += ' GROUP BY ' + groupBySQL;
+        }
+        if (this.havingConditions.length > 0) {
+            let havingConds = this.transformConditionColumns(this.havingConditions);
+            if (hasJoins) {
+                havingConds = this.qualifyWhereConditions(havingConds, tableRef);
+            }
+            query += ' HAVING ' + buildConditionsSQL(havingConds);
+        }
+        return query;
+    }
+}

package/dist/esm/select/sql-expression.js

@@ -0,0 +1,33 @@
+import { columnRefToSQL } from "./table-proxy.js";
+export class SqlExpression {
+    sql;
+    _isSqlExpression = true;
+    constructor(sql) {
+        this.sql = sql;
+    }
+}
+export class AggregateFunctions {
+    count(ref) {
+        if (!ref)
+            return new SqlExpression('COUNT(*)');
+        return new SqlExpression(`COUNT(${columnRefToSQL(ref)})`);
+    }
+    countDistinct(ref) {
+        return new SqlExpression(`COUNT(DISTINCT ${columnRefToSQL(ref)})`);
+    }
+    sum(ref) {
+        return new SqlExpression(`SUM(${columnRefToSQL(ref)})`);
+    }
+    avg(ref) {
+        return new SqlExpression(`AVG(${columnRefToSQL(ref)})`);
+    }
+    min(ref) {
+        return new SqlExpression(`MIN(${columnRefToSQL(ref)})`);
+    }
+    max(ref) {
+        return new SqlExpression(`MAX(${columnRefToSQL(ref)})`);
+    }
+    raw(sql) {
+        return new SqlExpression(sql);
+    }
+}

package/dist/esm/select/table-proxy.js

@@ -0,0 +1,91 @@
+export function isColumnRef(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '$table' in value &&
+        '$alias' in value &&
+        '$column' in value &&
+        '$sqlColumn' in value);
+}
+export function createTableProxy(tableName, alias, tableSchema) {
+    return new Proxy({}, {
+        get(_, prop) {
+            if (typeof prop === 'symbol') {
+                return undefined;
+            }
+            const columns = tableSchema?.$columns || tableSchema;
+            const columnDef = columns?.[prop];
+            let sqlColumn;
+            if (columnDef) {
+                sqlColumn = columnDef.$sqlName || columnDef.$name || camelToSnake(prop);
+            }
+            else {
+                sqlColumn = camelToSnake(prop);
+            }
+            return {
+                $table: tableName,
+                $alias: alias,
+                $column: prop,
+                $sqlColumn: sqlColumn,
+                $type: undefined
+            };
+        },
+        has(_, prop) {
+            if (typeof prop === 'symbol')
+                return false;
+            const columns = tableSchema?.$columns || tableSchema;
+            return columns ? prop in columns : true;
+        },
+        ownKeys(_) {
+            const columns = tableSchema?.$columns || tableSchema;
+            return columns ? Object.keys(columns) : [];
+        },
+        getOwnPropertyDescriptor(_, prop) {
+            if (typeof prop === 'symbol')
+                return undefined;
+            const columns = tableSchema?.$columns || tableSchema;
+            if (columns && prop in columns) {
+                const columnDef = columns[prop];
+                const sqlColumn = columnDef?.$sqlName || columnDef?.$name || camelToSnake(prop);
+                return {
+                    enumerable: true,
+                    configurable: true,
+                    value: {
+                        $table: tableName,
+                        $alias: alias,
+                        $column: prop,
+                        $sqlColumn: sqlColumn,
+                        $type: undefined
+                    }
+                };
+            }
+            return undefined;
+        }
+    });
+}
+export function createJoinCallbackParams(leftTableKey, leftAlias, leftTableDef, rightTableKey, rightAlias, rightTableDef) {
+    const leftTableName = leftTableDef?.$name || leftTableKey;
+    const rightTableName = rightTableDef?.$name || rightTableKey;
+    return {
+        leftProxy: createTableProxy(leftTableName, leftAlias, leftTableDef),
+        rightProxy: createTableProxy(rightTableName, rightAlias, rightTableDef),
+        leftTableName,
+        rightTableName
+    };
+}
+function camelToSnake(str) {
+    return str
+        .replace(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .replace(/^_/, '');
+}
+export function columnRefToSQL(ref) {
+    return `"${ref.$alias}"."${ref.$sqlColumn}"`;
+}
+export function columnRefToSQLUnqualified(ref) {
+    return `"${ref.$sqlColumn}"`;
+}
+export function columnRefsEqual(a, b) {
+    return a.$table === b.$table &&
+        a.$alias === b.$alias &&
+        a.$sqlColumn === b.$sqlColumn;
+}

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

@@ -0,0 +1,140 @@
+import process from 'node:process';
+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;
+}