relq 1.0.0

package/dist/esm/table/alter-table-builder.js

@@ -0,0 +1,138 @@
+import format from "../../addons/pg-format.js";
+import { RelqBuilderError } from "../errors/relq-errors.js";
+export class AlterTableBuilder {
+    tableName;
+    actions = [];
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    addColumn(name, definition, ifNotExists = false) {
+        const ifNotExistsClause = ifNotExists ? 'IF NOT EXISTS ' : '';
+        if (typeof definition === 'string') {
+            this.actions.push(`ADD COLUMN ${ifNotExistsClause}${format.ident(name)} ${definition}`);
+        }
+        else {
+            let colDef = format.ident(name) + ' ' + definition.type;
+            if (definition.generated) {
+                const generatedType = definition.generated.always !== false ? 'ALWAYS' : 'BY DEFAULT';
+                colDef += ` GENERATED ${generatedType} AS (${definition.generated.expression}) STORED`;
+            }
+            else {
+                if (definition.nullable === false)
+                    colDef += ' NOT NULL';
+                if (definition.default !== undefined)
+                    colDef += ` DEFAULT ${format('%L', definition.default)}`;
+            }
+            this.actions.push(`ADD COLUMN ${ifNotExistsClause}${colDef}`);
+        }
+        return this;
+    }
+    dropColumn(name, ifExists = false, cascade = false) {
+        const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+        const cascadeClause = cascade ? ' CASCADE' : '';
+        this.actions.push(`DROP COLUMN ${ifExistsClause}${format.ident(name)}${cascadeClause}`);
+        return this;
+    }
+    renameColumn(oldName, newName) {
+        this.actions.push(`RENAME COLUMN ${format.ident(oldName)} TO ${format.ident(newName)}`);
+        return this;
+    }
+    alterColumnType(name, newType, using) {
+        let action = `ALTER COLUMN ${format.ident(name)} TYPE ${newType}`;
+        if (using)
+            action += ` USING ${using}`;
+        this.actions.push(action);
+        return this;
+    }
+    setColumnDefault(name, defaultValue) {
+        this.actions.push(`ALTER COLUMN ${format.ident(name)} SET DEFAULT ${format('%L', defaultValue)}`);
+        return this;
+    }
+    dropColumnDefault(name) {
+        this.actions.push(`ALTER COLUMN ${format.ident(name)} DROP DEFAULT`);
+        return this;
+    }
+    setColumnNotNull(name) {
+        this.actions.push(`ALTER COLUMN ${format.ident(name)} SET NOT NULL`);
+        return this;
+    }
+    dropColumnNotNull(name) {
+        this.actions.push(`ALTER COLUMN ${format.ident(name)} DROP NOT NULL`);
+        return this;
+    }
+    addConstraint(name, constraint) {
+        this.actions.push(`ADD CONSTRAINT ${format.ident(name)} ${constraint}`);
+        return this;
+    }
+    dropConstraint(name, ifExists = false, cascade = false) {
+        const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+        const cascadeClause = cascade ? ' CASCADE' : '';
+        this.actions.push(`DROP CONSTRAINT ${ifExistsClause}${format.ident(name)}${cascadeClause}`);
+        return this;
+    }
+    renameTo(newName) {
+        this.actions.push(`RENAME TO ${format.ident(newName)}`);
+        return this;
+    }
+    setSchema(schemaName) {
+        this.actions.push(`SET SCHEMA ${format.ident(schemaName)}`);
+        return this;
+    }
+    setTablespace(tablespaceName) {
+        this.actions.push(`SET TABLESPACE ${format.ident(tablespaceName)}`);
+        return this;
+    }
+    enableTrigger(triggerName) {
+        this.actions.push(`ENABLE TRIGGER ${format.ident(triggerName)}`);
+        return this;
+    }
+    disableTrigger(triggerName) {
+        this.actions.push(`DISABLE TRIGGER ${format.ident(triggerName)}`);
+        return this;
+    }
+    enableAllTriggers() {
+        this.actions.push('ENABLE TRIGGER ALL');
+        return this;
+    }
+    disableAllTriggers() {
+        this.actions.push('DISABLE TRIGGER ALL');
+        return this;
+    }
+    toString() {
+        if (this.actions.length === 0) {
+            throw new RelqBuilderError('No ALTER TABLE actions specified', { builder: 'AlterTableBuilder', missing: 'actions', hint: 'Use addColumn(), dropColumn(), or other methods' });
+        }
+        return `ALTER TABLE ${format.ident(this.tableName)} ${this.actions.join(', ')}`;
+    }
+}
+export class DropTableBuilder {
+    tableName;
+    ifExistsFlag = false;
+    cascadeFlag = false;
+    constructor(tableName) {
+        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 TABLE';
+        if (this.ifExistsFlag) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${format.ident(this.tableName)}`;
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+}

package/dist/esm/table/constraint-builder.js

@@ -0,0 +1,95 @@
+import format from "../../addons/pg-format.js";
+export class ConstraintBuilder {
+    constraints = [];
+    addPrimaryKey(columns, name) {
+        this.constraints.push({
+            type: 'PRIMARY KEY',
+            name,
+            columns
+        });
+        return this;
+    }
+    addForeignKey(config) {
+        this.constraints.push({
+            type: 'FOREIGN KEY',
+            name: config.name,
+            columns: config.columns,
+            references: config.references,
+            onDelete: config.onDelete,
+            onUpdate: config.onUpdate,
+            deferrable: config.deferrable,
+            initially: config.initially
+        });
+        return this;
+    }
+    addUnique(columns, name) {
+        this.constraints.push({
+            type: 'UNIQUE',
+            name,
+            columns
+        });
+        return this;
+    }
+    addCheck(condition, name) {
+        this.constraints.push({
+            type: 'CHECK',
+            name,
+            definition: condition
+        });
+        return this;
+    }
+    addExclusion(constraint, using = 'GIST', name) {
+        this.constraints.push({
+            type: 'EXCLUSION',
+            name,
+            definition: constraint,
+            using
+        });
+        return this;
+    }
+    getConstraints() {
+        return this.constraints;
+    }
+    static buildConstraintSQL(constraint) {
+        let sql = '';
+        if (constraint.name) {
+            sql += `CONSTRAINT ${format.ident(constraint.name)} `;
+        }
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                sql += `PRIMARY KEY (${constraint.columns.map(c => format.ident(c)).join(', ')})`;
+                break;
+            case 'FOREIGN KEY': {
+                const cols = constraint.columns.map(c => format.ident(c)).join(', ');
+                const refCols = constraint.references.columns.map(c => format.ident(c)).join(', ');
+                sql += `FOREIGN KEY (${cols}) REFERENCES ${format.ident(constraint.references.table)} (${refCols})`;
+                if (constraint.onDelete) {
+                    sql += ` ON DELETE ${constraint.onDelete}`;
+                }
+                if (constraint.onUpdate) {
+                    sql += ` ON UPDATE ${constraint.onUpdate}`;
+                }
+                if (constraint.deferrable) {
+                    sql += ' DEFERRABLE';
+                    if (constraint.initially) {
+                        sql += ` INITIALLY ${constraint.initially}`;
+                    }
+                }
+                break;
+            }
+            case 'UNIQUE':
+                sql += `UNIQUE (${constraint.columns.map(c => format.ident(c)).join(', ')})`;
+                break;
+            case 'CHECK':
+                sql += `CHECK (${constraint.definition})`;
+                break;
+            case 'EXCLUSION':
+                sql += `EXCLUDE USING ${constraint.using} (${constraint.definition})`;
+                break;
+        }
+        return sql;
+    }
+    buildAllConstraintsSQL() {
+        return this.constraints.map(c => ConstraintBuilder.buildConstraintSQL(c));
+    }
+}

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

@@ -0,0 +1,241 @@
+import format from "../../addons/pg-format.js";
+import { ConstraintBuilder } from "./constraint-builder.js";
+import { PartitionBuilder } from "./partition-builder.js";
+import { CreateIndexBuilder } from "../indexing/create-index-builder.js";
+import { RelqBuilderError } from "../errors/relq-errors.js";
+export class CreateTableBuilder {
+    tableName;
+    columns = new Map();
+    constraintBuilder = new ConstraintBuilder();
+    partitionBuilder;
+    indexes = [];
+    inheritsFrom = [];
+    withOptions = {};
+    tablespaceValue;
+    ifNotExistsFlag = false;
+    temporaryFlag = false;
+    unloggedFlag = false;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    setColumns(columns) {
+        Object.entries(columns).forEach(([name, def]) => {
+            this.columns.set(name, def);
+        });
+        return this;
+    }
+    addColumn(name, definition) {
+        this.columns.set(name, definition);
+        return this;
+    }
+    addPrimaryKey(columns, name) {
+        this.constraintBuilder.addPrimaryKey(columns, name);
+        return this;
+    }
+    addForeignKey(config) {
+        this.constraintBuilder.addForeignKey(config);
+        return this;
+    }
+    addUnique(columns, name) {
+        this.constraintBuilder.addUnique(columns, name);
+        return this;
+    }
+    addCheck(condition, name) {
+        this.constraintBuilder.addCheck(condition, name);
+        return this;
+    }
+    addExclusion(constraint, using, name) {
+        this.constraintBuilder.addExclusion(constraint, using, name);
+        return this;
+    }
+    addIndex(name, callback) {
+        const indexBuilder = new CreateIndexBuilder(this.tableName, name);
+        callback(indexBuilder);
+        this.indexes.push({ name, builder: indexBuilder });
+        return this;
+    }
+    partitionBy(strategy, columns) {
+        this.partitionBuilder = new PartitionBuilder();
+        const cols = Array.isArray(columns) ? columns : [columns];
+        if (strategy === 'RANGE') {
+            this.partitionBuilder.range(...cols);
+        }
+        else if (strategy === 'LIST') {
+            this.partitionBuilder.list(cols[0]);
+        }
+        else {
+            this.partitionBuilder.hash(cols[0]);
+        }
+        return this;
+    }
+    inherits(...parentTables) {
+        this.inheritsFrom.push(...parentTables);
+        return this;
+    }
+    with(options) {
+        this.withOptions = { ...this.withOptions, ...options };
+        return this;
+    }
+    tablespace(name) {
+        this.tablespaceValue = name;
+        return this;
+    }
+    ifNotExists() {
+        this.ifNotExistsFlag = true;
+        return this;
+    }
+    temporary() {
+        this.temporaryFlag = true;
+        return this;
+    }
+    unlogged() {
+        this.unloggedFlag = true;
+        return this;
+    }
+    fillfactor(percent) {
+        this.withOptions.fillfactor = percent;
+        return this;
+    }
+    parallelWorkers(count) {
+        this.withOptions.parallel_workers = count;
+        return this;
+    }
+    autovacuum(enabled, options) {
+        this.withOptions.autovacuum_enabled = enabled;
+        if (options) {
+            if (options.vacuumThreshold !== undefined) {
+                this.withOptions.autovacuum_vacuum_threshold = options.vacuumThreshold;
+            }
+            if (options.analyzeThreshold !== undefined) {
+                this.withOptions.autovacuum_analyze_threshold = options.analyzeThreshold;
+            }
+            if (options.vacuumScaleFactor !== undefined) {
+                this.withOptions.autovacuum_vacuum_scale_factor = options.vacuumScaleFactor;
+            }
+            if (options.analyzeScaleFactor !== undefined) {
+                this.withOptions.autovacuum_analyze_scale_factor = options.analyzeScaleFactor;
+            }
+        }
+        return this;
+    }
+    buildColumnSQL(name, def) {
+        if (typeof def === 'string') {
+            return `${format.ident(name)} ${def}`;
+        }
+        let sql = format.ident(name);
+        sql += ` ${def.type}`;
+        if (def.collation) {
+            sql += ` COLLATE ${format.ident(def.collation)}`;
+        }
+        if (def.nullable === false) {
+            sql += ' NOT NULL';
+        }
+        else if (def.nullable === true) {
+            sql += ' NULL';
+        }
+        if (def.default !== undefined) {
+            if (typeof def.default === 'string' &&
+                (def.default.toUpperCase().includes('NOW()') ||
+                    def.default.toUpperCase().includes('CURRENT_'))) {
+                sql += ` DEFAULT ${def.default}`;
+            }
+            else {
+                sql += ` DEFAULT ${format('%L', def.default)}`;
+            }
+        }
+        if (def.generated) {
+            sql += def.generated.always ? ' GENERATED ALWAYS' : ' GENERATED BY DEFAULT';
+            sql += ` AS (${def.generated.expression}) STORED`;
+        }
+        if (def.identity) {
+            sql += def.identity.always ? ' GENERATED ALWAYS AS IDENTITY' : ' GENERATED BY DEFAULT AS IDENTITY';
+            const identityOpts = [];
+            if (def.identity.start !== undefined)
+                identityOpts.push(`START WITH ${def.identity.start}`);
+            if (def.identity.increment !== undefined)
+                identityOpts.push(`INCREMENT BY ${def.identity.increment}`);
+            if (def.identity.minValue !== undefined)
+                identityOpts.push(`MINVALUE ${def.identity.minValue}`);
+            if (def.identity.maxValue !== undefined)
+                identityOpts.push(`MAXVALUE ${def.identity.maxValue}`);
+            if (def.identity.cycle)
+                identityOpts.push('CYCLE');
+            if (identityOpts.length > 0) {
+                sql += ` (${identityOpts.join(' ')})`;
+            }
+        }
+        if (def.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        if (def.unique) {
+            sql += ' UNIQUE';
+        }
+        if (def.check) {
+            sql += ` CHECK (${def.check})`;
+        }
+        if (def.references) {
+            sql += ` REFERENCES ${format.ident(def.references.table)}(${format.ident(def.references.column)})`;
+            if (def.references.onDelete) {
+                sql += ` ON DELETE ${def.references.onDelete}`;
+            }
+            if (def.references.onUpdate) {
+                sql += ` ON UPDATE ${def.references.onUpdate}`;
+            }
+        }
+        if (def.storage) {
+            sql += ` STORAGE ${def.storage}`;
+        }
+        if (def.compression) {
+            sql += ` COMPRESSION ${def.compression}`;
+        }
+        return sql;
+    }
+    toString() {
+        if (this.columns.size === 0) {
+            throw new RelqBuilderError('Table must have at least one column', { builder: 'CreateTableBuilder', missing: 'columns', hint: 'Use .setColumns() or .addColumn()' });
+        }
+        let sql = 'CREATE';
+        if (this.temporaryFlag) {
+            sql += ' TEMPORARY';
+        }
+        if (this.unloggedFlag) {
+            sql += ' UNLOGGED';
+        }
+        sql += ' TABLE';
+        if (this.ifNotExistsFlag) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${format.ident(this.tableName)}`;
+        const columnDefs = [];
+        this.columns.forEach((def, name) => {
+            columnDefs.push(this.buildColumnSQL(name, def));
+        });
+        const constraints = this.constraintBuilder.buildAllConstraintsSQL();
+        sql += ` (${[...columnDefs, ...constraints].join(', ')})`;
+        if (this.inheritsFrom.length > 0) {
+            sql += ` INHERITS (${this.inheritsFrom.map(t => format.ident(t)).join(', ')})`;
+        }
+        if (this.partitionBuilder) {
+            sql += this.partitionBuilder.buildPartitionBySQL();
+        }
+        if (Object.keys(this.withOptions).length > 0) {
+            const options = Object.entries(this.withOptions)
+                .map(([key, value]) => `${key} = ${typeof value === 'boolean' ? (value ? 'on' : 'off') : value}`)
+                .join(', ');
+            sql += ` WITH (${options})`;
+        }
+        if (this.tablespaceValue) {
+            sql += ` TABLESPACE ${format.ident(this.tablespaceValue)}`;
+        }
+        return sql;
+    }
+    getIndexSQL() {
+        return this.indexes.map(({ builder }) => builder.toString());
+    }
+    toFullSQL() {
+        return {
+            table: this.toString(),
+            indexes: this.getIndexSQL()
+        };
+    }
+}

package/dist/esm/table/index.js

@@ -0,0 +1,5 @@
+export { CreateTableBuilder } from "./create-table-builder.js";
+export { AlterTableBuilder, DropTableBuilder } from "./alter-table-builder.js";
+export { ConstraintBuilder } from "./constraint-builder.js";
+export { PartitionBuilder, CreatePartitionBuilder, AttachPartitionBuilder, DetachPartitionBuilder } from "./partition-builder.js";
+export { TruncateBuilder } from "./truncate-builder.js";

package/dist/esm/table/partition-builder.js

@@ -0,0 +1,121 @@
+import format from "../../addons/pg-format.js";
+export class PartitionBuilder {
+    strategy;
+    columns = [];
+    range(...columns) {
+        this.strategy = 'RANGE';
+        this.columns = columns;
+        return this;
+    }
+    list(column) {
+        this.strategy = 'LIST';
+        this.columns = [column];
+        return this;
+    }
+    hash(column) {
+        this.strategy = 'HASH';
+        this.columns = [column];
+        return this;
+    }
+    getStrategy() {
+        return this.strategy;
+    }
+    getColumns() {
+        return this.columns;
+    }
+    buildPartitionBySQL() {
+        if (!this.strategy || this.columns.length === 0) {
+            return '';
+        }
+        const cols = this.columns.map(c => format.ident(c)).join(', ');
+        return ` PARTITION BY ${this.strategy} (${cols})`;
+    }
+}
+export class CreatePartitionBuilder {
+    partitionName;
+    parentTable;
+    forValuesClause;
+    tablespaceValue;
+    withOptions;
+    constructor(partitionName, parentTable) {
+        this.partitionName = partitionName;
+        this.parentTable = parentTable;
+    }
+    forValues(specification) {
+        this.forValuesClause = specification;
+        return this;
+    }
+    tablespace(name) {
+        this.tablespaceValue = name;
+        return this;
+    }
+    with(options) {
+        this.withOptions = options;
+        return this;
+    }
+    toString() {
+        let sql = format('CREATE TABLE %I PARTITION OF %I', this.partitionName, this.parentTable);
+        if (this.forValuesClause) {
+            sql += ` FOR VALUES ${this.forValuesClause}`;
+        }
+        if (this.withOptions && Object.keys(this.withOptions).length > 0) {
+            const options = Object.entries(this.withOptions)
+                .map(([key, value]) => `${key} = ${value}`)
+                .join(', ');
+            sql += ` WITH (${options})`;
+        }
+        if (this.tablespaceValue) {
+            sql += ` TABLESPACE ${format.ident(this.tablespaceValue)}`;
+        }
+        return sql;
+    }
+}
+export class AttachPartitionBuilder {
+    parentTable;
+    partitionName;
+    forValuesClause;
+    concurrentFlag = false;
+    constructor(parentTable, partitionName) {
+        this.parentTable = parentTable;
+        this.partitionName = partitionName;
+    }
+    forValues(specification) {
+        this.forValuesClause = specification;
+        return this;
+    }
+    toString() {
+        let sql = format('ALTER TABLE %I ATTACH PARTITION %I', this.parentTable, this.partitionName);
+        if (this.forValuesClause) {
+            sql += ` FOR VALUES ${this.forValuesClause}`;
+        }
+        return sql;
+    }
+}
+export class DetachPartitionBuilder {
+    parentTable;
+    partitionName;
+    concurrentFlag = false;
+    finalizeFlag = false;
+    constructor(parentTable, partitionName) {
+        this.parentTable = parentTable;
+        this.partitionName = partitionName;
+    }
+    concurrently() {
+        this.concurrentFlag = true;
+        return this;
+    }
+    finalize() {
+        this.finalizeFlag = true;
+        return this;
+    }
+    toString() {
+        let sql = format('ALTER TABLE %I DETACH PARTITION %I', this.parentTable, this.partitionName);
+        if (this.concurrentFlag) {
+            sql += ' CONCURRENTLY';
+        }
+        if (this.finalizeFlag) {
+            sql += ' FINALIZE';
+        }
+        return sql;
+    }
+}

package/dist/esm/table/truncate-builder.js

@@ -0,0 +1,63 @@
+import format from "../../addons/pg-format.js";
+export class TruncateBuilder {
+    tables;
+    cascadeFlag = false;
+    restrictFlag = false;
+    restartIdentityFlag = false;
+    continueIdentityFlag = false;
+    onlyFlag = false;
+    constructor(tables) {
+        this.tables = Array.isArray(tables) ? tables : [tables];
+    }
+    cascade() {
+        this.cascadeFlag = true;
+        this.restrictFlag = false;
+        return this;
+    }
+    restrict() {
+        this.restrictFlag = true;
+        this.cascadeFlag = false;
+        return this;
+    }
+    restartIdentity() {
+        this.restartIdentityFlag = true;
+        this.continueIdentityFlag = false;
+        return this;
+    }
+    continueIdentity() {
+        this.continueIdentityFlag = true;
+        this.restartIdentityFlag = false;
+        return this;
+    }
+    only() {
+        this.onlyFlag = true;
+        return this;
+    }
+    onlyIfEmpty() {
+        return this.only();
+    }
+    addTable(...tables) {
+        this.tables.push(...tables);
+        return this;
+    }
+    toString() {
+        let sql = 'TRUNCATE TABLE';
+        if (this.onlyFlag && this.tables.length === 1) {
+            sql += ' ONLY';
+        }
+        sql += ' ' + this.tables.map(t => format.ident(t)).join(', ');
+        if (this.restartIdentityFlag) {
+            sql += ' RESTART IDENTITY';
+        }
+        else if (this.continueIdentityFlag) {
+            sql += ' CONTINUE IDENTITY';
+        }
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        else if (this.restrictFlag) {
+            sql += ' RESTRICT';
+        }
+        return sql;
+    }
+}

package/dist/esm/transaction/index.js

@@ -0,0 +1 @@
+export { TransactionBuilder, SavepointBuilder } from "./transaction-builder.js";