relq 1.0.0

package/dist/cjs/select/aggregate-builder.cjs

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateQueryBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const NUMERIC_FUNCS = new Set(['COUNT', 'SUM', 'AVG', 'MIN', 'MAX']);
+class AggregateQueryBuilder {
+    tableName;
+    groupByColumns = [];
+    entries = [];
+    whereConditions = [];
+    havingConditions = [];
+    orderByColumns = [];
+    limitValue;
+    offsetValue;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    groupBy(...columns) {
+        this.groupByColumns.push(...columns);
+        return this;
+    }
+    count(alias = 'count') {
+        this.entries.push({ func: 'COUNT', column: '*', alias });
+        return this;
+    }
+    countColumn(column, alias) {
+        this.entries.push({ func: 'COUNT', column, alias: alias || column });
+        return this;
+    }
+    countDistinct(column, alias) {
+        this.entries.push({ func: 'COUNT', column, alias: alias || column, distinct: true });
+        return this;
+    }
+    sum(column, alias, filter) {
+        const entry = { func: 'SUM', column, alias: alias || column };
+        if (filter) {
+            const collector = new condition_collector_1.ConditionCollector();
+            filter(collector);
+            entry.filterConditions = collector.getConditions();
+        }
+        this.entries.push(entry);
+        return this;
+    }
+    avg(column, alias, filter) {
+        const entry = { func: 'AVG', column, alias: alias || column };
+        if (filter) {
+            const collector = new condition_collector_1.ConditionCollector();
+            filter(collector);
+            entry.filterConditions = collector.getConditions();
+        }
+        this.entries.push(entry);
+        return this;
+    }
+    min(column, alias) {
+        this.entries.push({ func: 'MIN', column, alias: alias || column });
+        return this;
+    }
+    max(column, alias) {
+        this.entries.push({ func: 'MAX', column, alias: alias || column });
+        return this;
+    }
+    arrayAgg(column, alias) {
+        this.entries.push({ func: 'ARRAY_AGG', column, alias: alias || column });
+        return this;
+    }
+    stringAgg(column, delimiter = ', ', alias) {
+        this.entries.push({ func: 'STRING_AGG', column, alias: alias || column, delimiter });
+        return this;
+    }
+    jsonAgg(column, alias) {
+        this.entries.push({ func: 'JSON_AGG', column, alias: alias || column });
+        return this;
+    }
+    jsonbAgg(column, alias) {
+        this.entries.push({ func: 'JSONB_AGG', column, alias: alias || column });
+        return this;
+    }
+    boolAnd(column, alias) {
+        this.entries.push({ func: 'BOOL_AND', column, alias: alias || column });
+        return this;
+    }
+    boolOr(column, alias) {
+        this.entries.push({ func: 'BOOL_OR', column, alias: alias || column });
+        return this;
+    }
+    where(callback) {
+        const collector = new condition_collector_1.ConditionCollector();
+        callback(collector);
+        this.whereConditions.push(...collector.getConditions());
+        return this;
+    }
+    having(callback) {
+        const collector = new condition_collector_1.ConditionCollector();
+        callback(collector);
+        this.havingConditions.push(...collector.getConditions());
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByColumns.push({ column, direction });
+        return this;
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    getNumericAliases() {
+        return this.entries
+            .filter(e => NUMERIC_FUNCS.has(e.func))
+            .map(e => e.alias);
+    }
+    getGroupByColumns() {
+        return this.groupByColumns;
+    }
+    toString() {
+        const selectParts = [];
+        for (const col of this.groupByColumns) {
+            selectParts.push(pg_format_1.default.ident(col));
+        }
+        for (const entry of this.entries) {
+            selectParts.push(this.buildEntrySQL(entry));
+        }
+        if (selectParts.length === 0) {
+            selectParts.push('COUNT(*) AS count');
+        }
+        let query = (0, pg_format_1.default)('SELECT %s FROM %I', selectParts.join(', '), this.tableName);
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(this.whereConditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            query += ' GROUP BY ' + this.groupByColumns.map(col => pg_format_1.default.ident(col)).join(', ');
+        }
+        if (this.havingConditions.length > 0) {
+            query += ' HAVING ' + (0, condition_collector_1.buildConditionsSQL)(this.havingConditions);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(o => `${pg_format_1.default.ident(o.column)} ${o.direction}`)
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += (0, pg_format_1.default)(' LIMIT %s', this.limitValue);
+        }
+        if (this.offsetValue !== undefined) {
+            query += (0, pg_format_1.default)(' OFFSET %s', this.offsetValue);
+        }
+        return query;
+    }
+    buildEntrySQL(entry) {
+        let columnExpr;
+        if (entry.column === '*') {
+            columnExpr = '*';
+        }
+        else if (entry.distinct) {
+            columnExpr = `DISTINCT ${pg_format_1.default.ident(entry.column)}`;
+        }
+        else if (entry.func === 'STRING_AGG' && entry.delimiter) {
+            columnExpr = `${pg_format_1.default.ident(entry.column)}, ${pg_format_1.default.literal(entry.delimiter)}`;
+        }
+        else {
+            columnExpr = pg_format_1.default.ident(entry.column);
+        }
+        let sql = `${entry.func}(${columnExpr})`;
+        if (entry.filterConditions && entry.filterConditions.length > 0) {
+            const filterSQL = (0, condition_collector_1.buildConditionsSQL)(entry.filterConditions);
+            sql += ` FILTER (WHERE ${filterSQL})`;
+        }
+        sql += ` AS ${pg_format_1.default.ident(entry.alias)}`;
+        return sql;
+    }
+}
+exports.AggregateQueryBuilder = AggregateQueryBuilder;

package/dist/cjs/select/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectBuilder = void 0;
+var select_builder_1 = require("./select-builder.cjs");
+Object.defineProperty(exports, "SelectBuilder", { enumerable: true, get: function () { return select_builder_1.SelectBuilder; } });

package/dist/cjs/select/select-builder.cjs

@@ -0,0 +1,233 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+class SelectBuilder {
+    tableName;
+    selectColumns = ['*'];
+    whereConditions = [];
+    havingConditions = [];
+    joinClauses = [];
+    groupByColumns = [];
+    orderByColumns = [];
+    limitValue;
+    offsetValue;
+    distinctOnColumns = [];
+    lockingClause;
+    unionQueries = [];
+    constructor(tableName, columns) {
+        this.tableName = tableName;
+        if (columns) {
+            this.selectColumns = Array.isArray(columns) ? columns : [columns];
+        }
+    }
+    distinct() {
+        this.selectColumns = this.selectColumns.map(col => {
+            if (typeof col === 'string') {
+                return col.startsWith('DISTINCT') ? col : `DISTINCT ${col}`;
+            }
+            return col;
+        });
+        return this;
+    }
+    where(callback) {
+        const conditionBuilder = new condition_collector_1.ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    join(table, condition) {
+        this.joinClauses.push(`JOIN ${pg_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    leftJoin(table, condition) {
+        this.joinClauses.push(`LEFT JOIN ${pg_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    rightJoin(table, condition) {
+        this.joinClauses.push(`RIGHT JOIN ${pg_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    innerJoin(table, condition) {
+        this.joinClauses.push(`INNER JOIN ${pg_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    groupBy(...columns) {
+        this.groupByColumns.push(...columns);
+        return this;
+    }
+    having(callback) {
+        const conditionBuilder = new condition_collector_1.ConditionCollector();
+        callback(conditionBuilder);
+        this.havingConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByColumns.push({ column, direction });
+        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 ${pg_format_1.default.ident(table)} ON ${condition}`);
+        return this;
+    }
+    crossJoin(table) {
+        this.joinClauses.push(`CROSS JOIN ${pg_format_1.default.ident(table)}`);
+        return this;
+    }
+    lateralJoin(subquery, left = false) {
+        const joinType = left ? 'LEFT JOIN LATERAL' : 'JOIN LATERAL';
+        this.joinClauses.push(`${joinType} ${subquery}`);
+        return this;
+    }
+    toString() {
+        const columns = this.selectColumns.map(col => {
+            if (col === '*')
+                return '*';
+            if (Array.isArray(col)) {
+                const [column, alias] = col;
+                return (0, pg_format_1.default)('%I AS %I', column, alias);
+            }
+            if (col.includes('(') || col.includes('DISTINCT') || col.includes(' AS ')) {
+                return col;
+            }
+            return pg_format_1.default.ident(col);
+        }).join(', ');
+        let query = 'SELECT';
+        if (this.distinctOnColumns.length > 0) {
+            const distinctCols = this.distinctOnColumns.map(col => pg_format_1.default.ident(col)).join(', ');
+            query += (0, pg_format_1.default)(' DISTINCT ON (%s)', distinctCols);
+        }
+        query += (0, pg_format_1.default)(' %s FROM %I', columns, this.tableName);
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(this.whereConditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            query += ' GROUP BY ' + this.groupByColumns.map(col => pg_format_1.default.ident(col)).join(', ');
+        }
+        if (this.havingConditions.length > 0) {
+            query += ' HAVING ' + (0, condition_collector_1.buildConditionsSQL)(this.havingConditions);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(order => (0, pg_format_1.default)('%I %s', order.column, order.direction))
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += (0, pg_format_1.default)(' LIMIT %s', this.limitValue);
+        }
+        if (this.offsetValue !== undefined) {
+            query += (0, pg_format_1.default)(' 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 = `SELECT COUNT(*) as count FROM ${pg_format_1.default.ident(this.tableName)}`;
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + (0, condition_collector_1.buildConditionsSQL)(this.whereConditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            query += ' GROUP BY ' + this.groupByColumns.map(col => pg_format_1.default.ident(col)).join(', ');
+        }
+        if (this.havingConditions.length > 0) {
+            query += ' HAVING ' + (0, condition_collector_1.buildConditionsSQL)(this.havingConditions);
+        }
+        return query;
+    }
+}
+exports.SelectBuilder = SelectBuilder;

package/dist/cjs/sequence/index.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropSequenceBuilder = exports.AlterSequenceBuilder = exports.CreateSequenceBuilder = void 0;
+var sequence_builder_1 = require("./sequence-builder.cjs");
+Object.defineProperty(exports, "CreateSequenceBuilder", { enumerable: true, get: function () { return sequence_builder_1.CreateSequenceBuilder; } });
+Object.defineProperty(exports, "AlterSequenceBuilder", { enumerable: true, get: function () { return sequence_builder_1.AlterSequenceBuilder; } });
+Object.defineProperty(exports, "DropSequenceBuilder", { enumerable: true, get: function () { return sequence_builder_1.DropSequenceBuilder; } });

package/dist/cjs/sequence/sequence-builder.cjs

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropSequenceBuilder = exports.AlterSequenceBuilder = exports.CreateSequenceBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+class CreateSequenceBuilder {
+    sequenceName;
+    options = {};
+    ifNotExistsFlag = false;
+    temporaryFlag = false;
+    unloggedFlag = false;
+    constructor(sequenceName) {
+        this.sequenceName = sequenceName;
+    }
+    ifNotExists() {
+        this.ifNotExistsFlag = true;
+        return this;
+    }
+    temporary() {
+        this.temporaryFlag = true;
+        return this;
+    }
+    unlogged() {
+        this.unloggedFlag = true;
+        return this;
+    }
+    as(type) {
+        this.options.as = type;
+        return this;
+    }
+    start(value) {
+        this.options.start = value;
+        return this;
+    }
+    increment(value) {
+        this.options.increment = value;
+        return this;
+    }
+    minValue(value) {
+        this.options.minValue = value;
+        return this;
+    }
+    maxValue(value) {
+        this.options.maxValue = value;
+        return this;
+    }
+    noMinValue() {
+        this.options.minValue = undefined;
+        return this;
+    }
+    noMaxValue() {
+        this.options.maxValue = undefined;
+        return this;
+    }
+    cache(count) {
+        this.options.cache = count;
+        return this;
+    }
+    cycle() {
+        this.options.cycle = true;
+        return this;
+    }
+    noCycle() {
+        this.options.cycle = false;
+        return this;
+    }
+    ownedBy(tableColumn) {
+        this.options.ownedBy = tableColumn;
+        return this;
+    }
+    ownedByNone() {
+        this.options.ownedBy = 'NONE';
+        return this;
+    }
+    toString() {
+        let sql = 'CREATE';
+        if (this.temporaryFlag) {
+            sql += ' TEMPORARY';
+        }
+        if (this.unloggedFlag) {
+            sql += ' UNLOGGED';
+        }
+        sql += ' SEQUENCE';
+        if (this.ifNotExistsFlag) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ' ' + pg_format_1.default.ident(this.sequenceName);
+        if (this.options.as) {
+            sql += ` AS ${this.options.as}`;
+        }
+        if (this.options.increment !== undefined) {
+            sql += ` INCREMENT BY ${this.options.increment}`;
+        }
+        if (this.options.minValue !== undefined) {
+            sql += ` MINVALUE ${this.options.minValue}`;
+        }
+        if (this.options.maxValue !== undefined) {
+            sql += ` MAXVALUE ${this.options.maxValue}`;
+        }
+        if (this.options.start !== undefined) {
+            sql += ` START WITH ${this.options.start}`;
+        }
+        if (this.options.cache !== undefined) {
+            sql += ` CACHE ${this.options.cache}`;
+        }
+        if (this.options.cycle === true) {
+            sql += ' CYCLE';
+        }
+        else if (this.options.cycle === false) {
+            sql += ' NO CYCLE';
+        }
+        if (this.options.ownedBy) {
+            sql += ` OWNED BY ${this.options.ownedBy}`;
+        }
+        return sql;
+    }
+}
+exports.CreateSequenceBuilder = CreateSequenceBuilder;
+class AlterSequenceBuilder {
+    sequenceName;
+    options = {};
+    ifExistsFlag = false;
+    constructor(sequenceName) {
+        this.sequenceName = sequenceName;
+    }
+    ifExists() {
+        this.ifExistsFlag = true;
+        return this;
+    }
+    restart(value) {
+        this.options.restart = value ?? true;
+        return this;
+    }
+    as(type) {
+        this.options.as = type;
+        return this;
+    }
+    start(value) {
+        this.options.start = value;
+        return this;
+    }
+    increment(value) {
+        this.options.increment = value;
+        return this;
+    }
+    minValue(value) {
+        this.options.minValue = value;
+        return this;
+    }
+    maxValue(value) {
+        this.options.maxValue = value;
+        return this;
+    }
+    noMinValue() {
+        this.options.minValue = undefined;
+        return this;
+    }
+    noMaxValue() {
+        this.options.maxValue = undefined;
+        return this;
+    }
+    cache(count) {
+        this.options.cache = count;
+        return this;
+    }
+    cycle() {
+        this.options.cycle = true;
+        return this;
+    }
+    noCycle() {
+        this.options.cycle = false;
+        return this;
+    }
+    ownedBy(tableColumn) {
+        this.options.ownedBy = tableColumn;
+        return this;
+    }
+    ownedByNone() {
+        this.options.ownedBy = 'NONE';
+        return this;
+    }
+    toString() {
+        let sql = 'ALTER SEQUENCE';
+        if (this.ifExistsFlag) {
+            sql += ' IF EXISTS';
+        }
+        sql += ' ' + pg_format_1.default.ident(this.sequenceName);
+        if (this.options.as) {
+            sql += ` AS ${this.options.as}`;
+        }
+        if (this.options.increment !== undefined) {
+            sql += ` INCREMENT BY ${this.options.increment}`;
+        }
+        if (this.options.minValue !== undefined) {
+            sql += ` MINVALUE ${this.options.minValue}`;
+        }
+        if (this.options.maxValue !== undefined) {
+            sql += ` MAXVALUE ${this.options.maxValue}`;
+        }
+        if (this.options.start !== undefined) {
+            sql += ` START WITH ${this.options.start}`;
+        }
+        if (this.options.cache !== undefined) {
+            sql += ` CACHE ${this.options.cache}`;
+        }
+        if (this.options.cycle === true) {
+            sql += ' CYCLE';
+        }
+        else if (this.options.cycle === false) {
+            sql += ' NO CYCLE';
+        }
+        if (this.options.ownedBy) {
+            sql += ` OWNED BY ${this.options.ownedBy}`;
+        }
+        if (this.options.restart === true) {
+            sql += ' RESTART';
+        }
+        else if (typeof this.options.restart === 'number') {
+            sql += ` RESTART WITH ${this.options.restart}`;
+        }
+        return sql;
+    }
+}
+exports.AlterSequenceBuilder = AlterSequenceBuilder;
+class DropSequenceBuilder {
+    sequenceNames;
+    ifExistsFlag = false;
+    cascadeFlag = false;
+    restrictFlag = false;
+    constructor(sequenceNames) {
+        this.sequenceNames = Array.isArray(sequenceNames) ? sequenceNames : [sequenceNames];
+    }
+    ifExists() {
+        this.ifExistsFlag = true;
+        return this;
+    }
+    cascade() {
+        this.cascadeFlag = true;
+        this.restrictFlag = false;
+        return this;
+    }
+    restrict() {
+        this.restrictFlag = true;
+        this.cascadeFlag = false;
+        return this;
+    }
+    toString() {
+        let sql = 'DROP SEQUENCE';
+        if (this.ifExistsFlag) {
+            sql += ' IF EXISTS';
+        }
+        sql += ' ' + this.sequenceNames.map(name => pg_format_1.default.ident(name)).join(', ');
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        else if (this.restrictFlag) {
+            sql += ' RESTRICT';
+        }
+        return sql;
+    }
+}
+exports.DropSequenceBuilder = DropSequenceBuilder;