relq 1.0.0

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

@@ -0,0 +1,70 @@
+import format from "../../addons/pg-format.js";
+export class TransactionBuilder {
+    isolationLevel;
+    mode;
+    __deferrable;
+    isolation(level) {
+        this.isolationLevel = level;
+        return this;
+    }
+    readWrite() {
+        this.mode = 'READ WRITE';
+        return this;
+    }
+    readOnly() {
+        this.mode = 'READ ONLY';
+        return this;
+    }
+    deferrable() {
+        this.__deferrable = true;
+        return this;
+    }
+    notDeferrable() {
+        this.__deferrable = false;
+        return this;
+    }
+    begin() {
+        let sql = 'BEGIN';
+        const options = [];
+        if (this.isolationLevel) {
+            options.push(`ISOLATION LEVEL ${this.isolationLevel}`);
+        }
+        if (this.mode) {
+            options.push(this.mode);
+        }
+        if (this.__deferrable !== undefined) {
+            options.push(this.__deferrable ? 'DEFERRABLE' : 'NOT DEFERRABLE');
+        }
+        if (options.length > 0) {
+            sql += ` ${options.join(', ')}`;
+        }
+        return sql;
+    }
+    commit() {
+        return 'COMMIT';
+    }
+    rollback() {
+        return 'ROLLBACK';
+    }
+    toString() {
+        return this.begin();
+    }
+}
+export class SavepointBuilder {
+    savepointName;
+    constructor(savepointName) {
+        this.savepointName = savepointName;
+    }
+    create() {
+        return `SAVEPOINT ${format.ident(this.savepointName)}`;
+    }
+    rollback() {
+        return `ROLLBACK TO SAVEPOINT ${format.ident(this.savepointName)}`;
+    }
+    release() {
+        return `RELEASE SAVEPOINT ${format.ident(this.savepointName)}`;
+    }
+    toString() {
+        return this.create();
+    }
+}

package/dist/esm/trigger/create-trigger-builder.js

@@ -0,0 +1,166 @@
+import format from "../../addons/pg-format.js";
+import { RelqBuilderError } from "../errors/relq-errors.js";
+export class CreateTriggerBuilder {
+    triggerName;
+    tableName;
+    timing;
+    events = [];
+    level = 'ROW';
+    whenCondition;
+    functionCall;
+    functionArgs = [];
+    updateOfColumns;
+    referencingOld;
+    referencingNew;
+    deferrableFlag;
+    initiallyValue;
+    orReplaceFlag = false;
+    constructor(triggerName) {
+        this.triggerName = triggerName;
+    }
+    on(tableName) {
+        this.tableName = tableName;
+        return this;
+    }
+    before(...events) {
+        this.timing = 'BEFORE';
+        this.events = events;
+        return this;
+    }
+    after(...events) {
+        this.timing = 'AFTER';
+        this.events = events;
+        return this;
+    }
+    insteadOf(...events) {
+        this.timing = 'INSTEAD OF';
+        this.events = events;
+        return this;
+    }
+    forEachRow() {
+        this.level = 'ROW';
+        return this;
+    }
+    forEachStatement() {
+        this.level = 'STATEMENT';
+        return this;
+    }
+    updateOf(...columns) {
+        this.updateOfColumns = columns;
+        return this;
+    }
+    when(condition) {
+        this.whenCondition = condition;
+        return this;
+    }
+    referencing(oldTable, newTable) {
+        this.referencingOld = oldTable;
+        this.referencingNew = newTable;
+        return this;
+    }
+    execute(functionName, ...args) {
+        this.functionCall = functionName;
+        this.functionArgs = args;
+        return this;
+    }
+    deferrable() {
+        this.deferrableFlag = true;
+        return this;
+    }
+    initiallyDeferred() {
+        this.deferrableFlag = true;
+        this.initiallyValue = 'DEFERRED';
+        return this;
+    }
+    initiallyImmediate() {
+        this.deferrableFlag = true;
+        this.initiallyValue = 'IMMEDIATE';
+        return this;
+    }
+    orReplace() {
+        this.orReplaceFlag = true;
+        return this;
+    }
+    toString() {
+        if (!this.tableName) {
+            throw new RelqBuilderError('Table name is required for trigger creation', { builder: 'CreateTriggerBuilder', missing: 'tableName', hint: 'Use .on(tableName)' });
+        }
+        if (!this.timing || this.events.length === 0) {
+            throw new RelqBuilderError('Trigger timing and events are required', { builder: 'CreateTriggerBuilder', missing: 'timing/events', hint: 'Use .before(), .after(), or .insteadOf()' });
+        }
+        if (!this.functionCall) {
+            throw new RelqBuilderError('Trigger function is required', { builder: 'CreateTriggerBuilder', missing: 'function', hint: 'Use .execute(functionName)' });
+        }
+        let sql = 'CREATE';
+        if (this.orReplaceFlag) {
+            sql += ' OR REPLACE';
+        }
+        sql += ` TRIGGER ${format.ident(this.triggerName)}`;
+        sql += ` ${this.timing}`;
+        sql += ` ${this.events.join(' OR ')}`;
+        sql += ` ON ${format.ident(this.tableName)}`;
+        if (this.deferrableFlag) {
+            sql += ' DEFERRABLE';
+            if (this.initiallyValue) {
+                sql += ` INITIALLY ${this.initiallyValue}`;
+            }
+        }
+        if (this.referencingOld || this.referencingNew) {
+            sql += ' REFERENCING';
+            if (this.referencingOld) {
+                sql += ` OLD TABLE AS ${format.ident(this.referencingOld)}`;
+            }
+            if (this.referencingNew) {
+                if (this.referencingOld)
+                    sql += ' ';
+                sql += `NEW TABLE AS ${format.ident(this.referencingNew)}`;
+            }
+        }
+        sql += ` FOR EACH ${this.level}`;
+        if (this.whenCondition) {
+            sql += ` WHEN (${this.whenCondition})`;
+        }
+        sql += ` EXECUTE FUNCTION ${this.functionCall}`;
+        if (this.functionArgs.length > 0) {
+            const args = this.functionArgs.map(arg => format('%L', arg)).join(', ');
+            sql = sql.replace(this.functionCall, `${this.functionCall}(${args})`);
+        }
+        else if (!this.functionCall.includes('(')) {
+            sql += '()';
+        }
+        return sql;
+    }
+}
+export class DropTriggerBuilder {
+    triggerName;
+    tableName;
+    ifExistsFlag = false;
+    cascadeFlag = false;
+    constructor(triggerName, tableName) {
+        this.triggerName = triggerName;
+        this.tableName = tableName;
+    }
+    ifExists() {
+        this.ifExistsFlag = true;
+        return this;
+    }
+    cascade() {
+        this.cascadeFlag = true;
+        return this;
+    }
+    restrict() {
+        this.cascadeFlag = false;
+        return this;
+    }
+    toString() {
+        let sql = 'DROP TRIGGER';
+        if (this.ifExistsFlag) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${format.ident(this.triggerName)} ON ${format.ident(this.tableName)}`;
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+}

package/dist/esm/trigger/index.js

@@ -0,0 +1 @@
+export { CreateTriggerBuilder, DropTriggerBuilder } from "./create-trigger-builder.js";

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,36 @@
+import { mergeWithDefaults } from "../utils/pool-defaults.js";
+export function isPoolingEnabled(config) {
+    return config.pooling !== false;
+}
+export function toPoolConfig(config) {
+    const smartDefaults = config.disableSmartDefaults
+        ? { min: 0, max: 10, idleTimeoutMillis: 30000, connectionTimeoutMillis: 0 }
+        : mergeWithDefaults(config.pool);
+    const poolConfig = {
+        host: config.host || 'localhost',
+        port: config.port || 5432,
+        database: config.database,
+        user: config.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,
+        allowExitOnIdle: true
+    };
+    if (config.connectionString) {
+        return {
+            connectionString: config.connectionString,
+            min: poolConfig.min,
+            max: poolConfig.max,
+            idleTimeoutMillis: poolConfig.idleTimeoutMillis,
+            connectionTimeoutMillis: poolConfig.connectionTimeoutMillis,
+            application_name: poolConfig.application_name,
+            ssl: poolConfig.ssl,
+            allowExitOnIdle: true
+        };
+    }
+    return poolConfig;
+}

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

@@ -0,0 +1,12 @@
+export function isColumnAlias(col) {
+    return Array.isArray(col) && col.length === 2;
+}
+export function isAggregateColumn(col) {
+    return /^[a-z_]+\(/i.test(col);
+}
+export function getColumnName(col) {
+    return isColumnAlias(col) ? col[0] : col;
+}
+export function getResultKey(col) {
+    return isColumnAlias(col) ? col[1] : col;
+}

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

@@ -0,0 +1,4 @@
+export function randomLimit(range) {
+    const [min, max] = range;
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/update/array-update-builder.js

@@ -0,0 +1,192 @@
+import format from "../../addons/pg-format.js";
+export class ArrayStringUpdateBuilder {
+    set(values) {
+        if (values.length === 0)
+            return 'ARRAY[]::text[]';
+        const formatted = values.map(v => format('%L', v)).join(',');
+        return `ARRAY[${formatted}]`;
+    }
+    append(value) {
+        return format('array_append(%I, %L)', this.getContextColumn(), value);
+    }
+    prepend(value) {
+        return format('array_prepend(%L, %I)', value, this.getContextColumn());
+    }
+    remove(value) {
+        return format('array_remove(%I, %L)', this.getContextColumn(), value);
+    }
+    concat(values) {
+        if (values.length === 0)
+            return format('%I', this.getContextColumn());
+        const formatted = values.map(v => format('%L', v)).join(',');
+        return format('%I || ARRAY[%s]', this.getContextColumn(), formatted);
+    }
+    getContextColumn() {
+        return '__COLUMN__';
+    }
+}
+export class ArrayNumericUpdateBuilder {
+    set(values) {
+        if (values.length === 0)
+            return 'ARRAY[]::integer[]';
+        return `ARRAY[${values.join(',')}]`;
+    }
+    append(value) {
+        return format('array_append(%I, %s)', this.getContextColumn(), value);
+    }
+    prepend(value) {
+        return format('array_prepend(%s, %I)', value, this.getContextColumn());
+    }
+    remove(value) {
+        return format('array_remove(%I, %s)', this.getContextColumn(), value);
+    }
+    concat(values) {
+        if (values.length === 0)
+            return format('%I', this.getContextColumn());
+        return format('%I || ARRAY[%s]', this.getContextColumn(), values.join(','));
+    }
+    getContextColumn() {
+        return '__COLUMN__';
+    }
+}
+export class ArrayBooleanUpdateBuilder {
+    set(values) {
+        if (values.length === 0)
+            return 'ARRAY[]::boolean[]';
+        return `ARRAY[${values.map(v => v.toString()).join(',')}]`;
+    }
+    append(value) {
+        return format('array_append(%I, %s)', this.getContextColumn(), value.toString());
+    }
+    prepend(value) {
+        return format('array_prepend(%s, %I)', value.toString(), this.getContextColumn());
+    }
+    remove(value) {
+        return format('array_remove(%I, %s)', this.getContextColumn(), value.toString());
+    }
+    concat(values) {
+        if (values.length === 0)
+            return format('%I', this.getContextColumn());
+        return format('%I || ARRAY[%s]', this.getContextColumn(), values.map(v => v.toString()).join(','));
+    }
+    getContextColumn() {
+        return '__COLUMN__';
+    }
+}
+export class ArrayUuidUpdateBuilder {
+    set(values) {
+        if (values.length === 0)
+            return 'ARRAY[]::uuid[]';
+        const formatted = values.map(v => format('%L::uuid', v)).join(',');
+        return `ARRAY[${formatted}]`;
+    }
+    append(value) {
+        return format('array_append(%I, %L::uuid)', this.getContextColumn(), value);
+    }
+    prepend(value) {
+        return format('array_prepend(%L::uuid, %I)', value, this.getContextColumn());
+    }
+    remove(value) {
+        return format('array_remove(%I, %L::uuid)', this.getContextColumn(), value);
+    }
+    concat(values) {
+        if (values.length === 0)
+            return format('%I', this.getContextColumn());
+        const formatted = values.map(v => format('%L::uuid', v)).join(',');
+        return format('%I || ARRAY[%s]', this.getContextColumn(), formatted);
+    }
+    getContextColumn() {
+        return '__COLUMN__';
+    }
+}
+export class ArrayDateUpdateBuilder {
+    set(values) {
+        if (values.length === 0)
+            return 'ARRAY[]::timestamp[]';
+        const formatted = values.map(v => {
+            const dateStr = v instanceof Date ? v.toISOString() : v;
+            return format('%L::timestamp', dateStr);
+        }).join(',');
+        return `ARRAY[${formatted}]`;
+    }
+    append(value) {
+        const dateStr = value instanceof Date ? value.toISOString() : value;
+        return format('array_append(%I, %L::timestamp)', this.getContextColumn(), dateStr);
+    }
+    prepend(value) {
+        const dateStr = value instanceof Date ? value.toISOString() : value;
+        return format('array_prepend(%L::timestamp, %I)', dateStr, this.getContextColumn());
+    }
+    remove(value) {
+        const dateStr = value instanceof Date ? value.toISOString() : value;
+        return format('array_remove(%I, %L::timestamp)', this.getContextColumn(), dateStr);
+    }
+    concat(values) {
+        if (values.length === 0)
+            return format('%I', this.getContextColumn());
+        const formatted = values.map(v => {
+            const dateStr = v instanceof Date ? v.toISOString() : v;
+            return format('%L::timestamp', dateStr);
+        }).join(',');
+        return format('%I || ARRAY[%s]', this.getContextColumn(), formatted);
+    }
+    getContextColumn() {
+        return '__COLUMN__';
+    }
+}
+export class ArrayJsonbUpdateBuilder {
+    set(values) {
+        if (values.length === 0)
+            return 'ARRAY[]::jsonb[]';
+        const formatted = values.map(v => format('%L::jsonb', JSON.stringify(v))).join(',');
+        return `ARRAY[${formatted}]`;
+    }
+    append(value) {
+        return format('array_append(%I, %L::jsonb)', this.getContextColumn(), JSON.stringify(value));
+    }
+    prepend(value) {
+        return format('array_prepend(%L::jsonb, %I)', JSON.stringify(value), this.getContextColumn());
+    }
+    remove(value) {
+        return format('array_remove(%I, %L::jsonb)', this.getContextColumn(), JSON.stringify(value));
+    }
+    concat(values) {
+        if (values.length === 0)
+            return format('%I', this.getContextColumn());
+        const formatted = values.map(v => format('%L::jsonb', JSON.stringify(v))).join(',');
+        return format('%I || ARRAY[%s]', this.getContextColumn(), formatted);
+    }
+    getContextColumn() {
+        return '__COLUMN__';
+    }
+}
+export class ArrayUpdateBuilder {
+    currentColumn;
+    constructor(currentColumn) {
+        this.currentColumn = currentColumn;
+    }
+    get string() {
+        return new ArrayStringUpdateBuilder();
+    }
+    get numeric() {
+        return new ArrayNumericUpdateBuilder();
+    }
+    get integer() {
+        return this.numeric;
+    }
+    get boolean() {
+        return new ArrayBooleanUpdateBuilder();
+    }
+    get uuid() {
+        return new ArrayUuidUpdateBuilder();
+    }
+    get date() {
+        return new ArrayDateUpdateBuilder();
+    }
+    get timestamp() {
+        return this.date;
+    }
+    get jsonb() {
+        return new ArrayJsonbUpdateBuilder();
+    }
+}

package/dist/esm/update/index.js

@@ -0,0 +1,2 @@
+export { UpdateBuilder } from "./update-builder.js";
+export { ArrayUpdateBuilder, ArrayStringUpdateBuilder, ArrayNumericUpdateBuilder, ArrayBooleanUpdateBuilder, ArrayUuidUpdateBuilder, ArrayDateUpdateBuilder, ArrayJsonbUpdateBuilder } from "./array-update-builder.js";

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

@@ -0,0 +1,188 @@
+import format from "../../addons/pg-format.js";
+import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
+import { convertCase } from "../utils/case-converter.js";
+import { ArrayUpdateBuilder } from "./array-update-builder.js";
+import { SelectBuilder } from "../select/select-builder.js";
+import { CountBuilder } from "../count/count-builder.js";
+export class UpdateBuilder {
+    tableName;
+    updateData;
+    whereConditions = [];
+    returningClause;
+    _case = 'keep-case';
+    _convertCase = '2snake';
+    constructor(tableName, data) {
+        this.tableName = tableName;
+        this.updateData = data;
+    }
+    convertCase(type, conversionCase = '2snake') {
+        this._case = type;
+        this._convertCase = conversionCase;
+        return this;
+    }
+    where(callback) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    returning(columns) {
+        if (columns === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'columns',
+                columns: Array.isArray(columns) ? columns : [columns]
+            };
+        }
+        return this;
+    }
+    returningSelect(callback) {
+        const builder = new SelectBuilder(this.tableName);
+        const result = callback(builder);
+        if (result === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'select',
+                builder: result
+            };
+        }
+        return this;
+    }
+    returningCount(callback) {
+        const builder = new CountBuilder(this.tableName);
+        const result = callback(builder);
+        if (result === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'count',
+                builder: result
+            };
+        }
+        return this;
+    }
+    convertColumnName(name) {
+        if (this._case === 'to-lower')
+            return name.toLowerCase();
+        if (this._case === 'to-upper')
+            return name.toUpperCase();
+        if (this._case === 'convert-case')
+            return convertCase(name, this._convertCase);
+        return name;
+    }
+    formatArrayValue(value) {
+        if (value.length === 0)
+            return 'ARRAY[]';
+        const firstElement = value[0];
+        const firstType = typeof firstElement;
+        const isHomogeneous = value.every(v => typeof v === firstType);
+        if (!isHomogeneous) {
+            const jsonValues = value.map(v => format('%L::jsonb', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]`;
+        }
+        if (firstType === 'string') {
+            const stringValues = value.map(v => format('%L', v)).join(',');
+            return `ARRAY[${stringValues}]`;
+        }
+        if (firstType === 'number') {
+            return `ARRAY[${value.join(',')}]`;
+        }
+        if (firstType === 'boolean') {
+            return `ARRAY[${value.map(v => v.toString()).join(',')}]`;
+        }
+        if (firstType === 'object' && firstElement !== null) {
+            const jsonValues = value.map(v => format('%L::jsonb', JSON.stringify(v))).join(',');
+            return `ARRAY[${jsonValues}]`;
+        }
+        const stringValues = value.map(v => format('%L', v)).join(',');
+        return `ARRAY[${stringValues}]`;
+    }
+    toString() {
+        const processedPairs = Object.entries(this.updateData).map(([col, val]) => {
+            const convertedCol = this.convertColumnName(col);
+            if (typeof val === 'function') {
+                const arrayBuilder = new ArrayUpdateBuilder(col);
+                const result = val(arrayBuilder);
+                const finalResult = result.replace(/__COLUMN__/g, format.ident(convertedCol));
+                return format('%I = %s', convertedCol, finalResult);
+            }
+            if (Array.isArray(val)) {
+                return format('%I = %s', convertedCol, this.formatArrayValue(val));
+            }
+            return format('%I = %L', convertedCol, val);
+        });
+        let query = format('UPDATE %I SET %s', this.tableName, processedPairs.join(', '));
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + buildConditionsSQL(this.whereConditions);
+        }
+        if (this.returningClause) {
+            query += this.buildReturningClause();
+        }
+        return query;
+    }
+    parseCountColumns(columnsStr) {
+        const columns = [];
+        let depth = 0;
+        let currentExpr = '';
+        let i = 0;
+        while (i < columnsStr.length) {
+            const char = columnsStr[i];
+            if (char === '(')
+                depth++;
+            else if (char === ')')
+                depth--;
+            else if (char === ',' && depth === 0) {
+                if (currentExpr.trim()) {
+                    columns.push(this.parseColumnExpr(currentExpr.trim()));
+                }
+                currentExpr = '';
+                i++;
+                continue;
+            }
+            currentExpr += char;
+            i++;
+        }
+        if (currentExpr.trim()) {
+            columns.push(this.parseColumnExpr(currentExpr.trim()));
+        }
+        return columns;
+    }
+    parseColumnExpr(expr) {
+        const asMatch = expr.match(/^(.+?)\s+AS\s+(.+)$/i);
+        if (!asMatch) {
+            return { name: 'count', expr };
+        }
+        const [, expression, alias] = asMatch;
+        const name = alias.replace(/^["']|["']$/g, '');
+        return { name, expr: expression.trim() };
+    }
+    buildReturningClause() {
+        if (!this.returningClause)
+            return '';
+        switch (this.returningClause.type) {
+            case 'columns':
+                return format(' RETURNING %I', this.returningClause.columns);
+            case 'select': {
+                const selectSQL = this.returningClause.builder.toString();
+                return ` RETURNING (${selectSQL})`;
+            }
+            case 'count': {
+                const countSQL = this.returningClause.builder.toString();
+                const selectMatch = countSQL.match(/^SELECT\s+(.+?)\s+FROM\s+(.+)$/is);
+                if (!selectMatch)
+                    return ` RETURNING (${countSQL})`;
+                const [, columnsStr, fromClause] = selectMatch;
+                const columns = this.parseCountColumns(columnsStr);
+                const jsonArgs = columns.map(({ name, expr }) => `${format('%L', name)}, ${expr}`).join(', ');
+                return ` RETURNING (SELECT json_build_object(${jsonArgs}) FROM ${fromClause})`;
+            }
+            default:
+                return '';
+        }
+    }
+}