relq 1.0.0

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

@@ -0,0 +1,172 @@
+import format from "../../addons/pg-format.js";
+import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
+const NUMERIC_FUNCS = new Set(['COUNT', 'SUM', 'AVG', 'MIN', 'MAX']);
+export 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 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 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 ConditionCollector();
+        callback(collector);
+        this.whereConditions.push(...collector.getConditions());
+        return this;
+    }
+    having(callback) {
+        const collector = new 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(format.ident(col));
+        }
+        for (const entry of this.entries) {
+            selectParts.push(this.buildEntrySQL(entry));
+        }
+        if (selectParts.length === 0) {
+            selectParts.push('COUNT(*) AS count');
+        }
+        let query = format('SELECT %s FROM %I', selectParts.join(', '), this.tableName);
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + buildConditionsSQL(this.whereConditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            query += ' GROUP BY ' + this.groupByColumns.map(col => format.ident(col)).join(', ');
+        }
+        if (this.havingConditions.length > 0) {
+            query += ' HAVING ' + buildConditionsSQL(this.havingConditions);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(o => `${format.ident(o.column)} ${o.direction}`)
+                .join(', ');
+        }
+        if (this.limitValue !== undefined) {
+            query += format(' LIMIT %s', this.limitValue);
+        }
+        if (this.offsetValue !== undefined) {
+            query += format(' OFFSET %s', this.offsetValue);
+        }
+        return query;
+    }
+    buildEntrySQL(entry) {
+        let columnExpr;
+        if (entry.column === '*') {
+            columnExpr = '*';
+        }
+        else if (entry.distinct) {
+            columnExpr = `DISTINCT ${format.ident(entry.column)}`;
+        }
+        else if (entry.func === 'STRING_AGG' && entry.delimiter) {
+            columnExpr = `${format.ident(entry.column)}, ${format.literal(entry.delimiter)}`;
+        }
+        else {
+            columnExpr = format.ident(entry.column);
+        }
+        let sql = `${entry.func}(${columnExpr})`;
+        if (entry.filterConditions && entry.filterConditions.length > 0) {
+            const filterSQL = buildConditionsSQL(entry.filterConditions);
+            sql += ` FILTER (WHERE ${filterSQL})`;
+        }
+        sql += ` AS ${format.ident(entry.alias)}`;
+        return sql;
+    }
+}

package/dist/esm/select/index.js

@@ -0,0 +1 @@
+export { SelectBuilder } from "./select-builder.js";

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

@@ -0,0 +1,226 @@
+import format from "../../addons/pg-format.js";
+import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
+export 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 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;
+    }
+    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;
+    }
+    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;
+    }
+    toString() {
+        const columns = this.selectColumns.map(col => {
+            if (col === '*')
+                return '*';
+            if (Array.isArray(col)) {
+                const [column, alias] = col;
+                return format('%I AS %I', column, alias);
+            }
+            if (col.includes('(') || col.includes('DISTINCT') || col.includes(' AS ')) {
+                return col;
+            }
+            return format.ident(col);
+        }).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);
+        }
+        query += format(' %s FROM %I', columns, this.tableName);
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + buildConditionsSQL(this.whereConditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            query += ' GROUP BY ' + this.groupByColumns.map(col => format.ident(col)).join(', ');
+        }
+        if (this.havingConditions.length > 0) {
+            query += ' HAVING ' + buildConditionsSQL(this.havingConditions);
+        }
+        if (this.orderByColumns.length > 0) {
+            query += ' ORDER BY ' + this.orderByColumns
+                .map(order => format('%I %s', order.column, order.direction))
+                .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 = `SELECT COUNT(*) as count FROM ${format.ident(this.tableName)}`;
+        if (this.joinClauses.length > 0) {
+            query += ' ' + this.joinClauses.join(' ');
+        }
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + buildConditionsSQL(this.whereConditions);
+        }
+        if (this.groupByColumns.length > 0) {
+            query += ' GROUP BY ' + this.groupByColumns.map(col => format.ident(col)).join(', ');
+        }
+        if (this.havingConditions.length > 0) {
+            query += ' HAVING ' + buildConditionsSQL(this.havingConditions);
+        }
+        return query;
+    }
+}

package/dist/esm/sequence/index.js

@@ -0,0 +1 @@
+export { CreateSequenceBuilder, AlterSequenceBuilder, DropSequenceBuilder } from "./sequence-builder.js";

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

@@ -0,0 +1,255 @@
+import format from "../../addons/pg-format.js";
+export 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 += ' ' + format.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;
+    }
+}
+export 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 += ' ' + format.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;
+    }
+}
+export 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 => format.ident(name)).join(', ');
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        else if (this.restrictFlag) {
+            sql += ' RESTRICT';
+        }
+        return sql;
+    }
+}