relq 1.0.0

package/dist/cjs/condition/range-condition-builder.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeConditionCollector = void 0;
+exports.buildRangeConditionSQL = buildRangeConditionSQL;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+class RangeConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    contains(column, value) {
+        this.parent.conditions.push({
+            method: 'range_contains',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    containedBy(column, range) {
+        this.parent.conditions.push({
+            method: 'range_contained_by',
+            column,
+            values: range
+        });
+        return this.parent;
+    }
+    overlaps(column, range) {
+        this.parent.conditions.push({
+            method: 'range_overlaps',
+            column,
+            values: range
+        });
+        return this.parent;
+    }
+    strictlyLeft(column, range) {
+        this.parent.conditions.push({
+            method: 'range_strictly_left',
+            column,
+            values: range
+        });
+        return this.parent;
+    }
+    strictlyRight(column, range) {
+        this.parent.conditions.push({
+            method: 'range_strictly_right',
+            column,
+            values: range
+        });
+        return this.parent;
+    }
+    adjacent(column, range) {
+        this.parent.conditions.push({
+            method: 'range_adjacent',
+            column,
+            values: range
+        });
+        return this.parent;
+    }
+}
+exports.RangeConditionCollector = RangeConditionCollector;
+function buildRangeConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'range_contains':
+            return (0, pg_format_1.default)('%I @> %L', column, values);
+        case 'range_contained_by':
+            return (0, pg_format_1.default)('%I <@ %L', column, values);
+        case 'range_overlaps':
+            return (0, pg_format_1.default)('%I && %L', column, values);
+        case 'range_strictly_left':
+            return (0, pg_format_1.default)('%I << %L', column, values);
+        case 'range_strictly_right':
+            return (0, pg_format_1.default)('%I >> %L', column, values);
+        case 'range_adjacent':
+            return (0, pg_format_1.default)('%I -|- %L', column, values);
+        default:
+            return '';
+    }
+}

package/dist/cjs/config/config.cjs

@@ -0,0 +1,190 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = defineConfig;
+exports.loadConfig = loadConfig;
+exports.parseConnectionUrl = parseConnectionUrl;
+exports.mergeConfigs = mergeConfigs;
+exports.validateConfig = validateConfig;
+function defineConfig(config) {
+    return {
+        ...config,
+        pool: {
+            min: 2,
+            max: 10,
+            idleTimeoutMs: 30000,
+            connectionTimeoutMs: 5000,
+            ...config.pool,
+        },
+        logging: {
+            queries: false,
+            parameters: false,
+            timing: false,
+            errors: true,
+            level: 'error',
+            ...config.logging,
+        },
+        cache: {
+            enabled: false,
+            strategy: 'lru',
+            maxSize: 1000,
+            ttl: 60000,
+            ...config.cache,
+        },
+        conventions: {
+            timestamps: {
+                createdAt: 'created_at',
+                updatedAt: 'updated_at',
+                deletedAt: false,
+            },
+            softDelete: false,
+            primaryKey: 'id',
+            ...config.conventions,
+        },
+    };
+}
+function loadConfig(path) {
+    const configPath = path || findConfigFile();
+    if (!configPath) {
+        return Promise.resolve(defineConfig({}));
+    }
+    return Promise.resolve(`${configPath}`).then(s => __importStar(require(s))).then(module => {
+        if (module.default) {
+            return module.default;
+        }
+        return defineConfig({});
+    }).catch(() => {
+        return defineConfig({});
+    });
+}
+function findConfigFile() {
+    return null;
+}
+function parseConnectionUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return {
+            url,
+            host: parsed.hostname,
+            port: parsed.port ? parseInt(parsed.port, 10) : 5432,
+            database: parsed.pathname.slice(1),
+            user: parsed.username,
+            password: parsed.password,
+            ssl: parsed.searchParams.get('sslmode') || undefined,
+        };
+    }
+    catch {
+        return { url };
+    }
+}
+function mergeConfigs(...configs) {
+    let result = {};
+    for (const config of configs) {
+        result = {
+            ...result,
+            ...config,
+            connection: config.connection !== undefined
+                ? { ...result.connection, ...config.connection }
+                : result.connection,
+            schema: config.schema !== undefined
+                ? (typeof config.schema === 'string'
+                    ? config.schema
+                    : (typeof result.schema === 'object'
+                        ? { ...result.schema, ...config.schema }
+                        : config.schema))
+                : result.schema,
+            migrations: config.migrations !== undefined
+                ? { ...result.migrations, ...config.migrations }
+                : result.migrations,
+            typeGeneration: config.typeGeneration !== undefined
+                ? { ...result.typeGeneration, ...config.typeGeneration }
+                : result.typeGeneration,
+            logging: config.logging !== undefined
+                ? { ...result.logging, ...config.logging }
+                : result.logging,
+            cache: config.cache !== undefined
+                ? { ...result.cache, ...config.cache }
+                : result.cache,
+            pool: config.pool !== undefined
+                ? { ...result.pool, ...config.pool }
+                : result.pool,
+            conventions: config.conventions !== undefined
+                ? {
+                    ...result.conventions,
+                    ...config.conventions,
+                    timestamps: config.conventions?.timestamps !== undefined
+                        ? { ...result.conventions?.timestamps, ...config.conventions.timestamps }
+                        : result.conventions?.timestamps,
+                }
+                : result.conventions,
+            plugins: config.plugins !== undefined
+                ? [...(result.plugins || []), ...config.plugins]
+                : result.plugins,
+        };
+    }
+    return defineConfig(result);
+}
+function validateConfig(config) {
+    const errors = [];
+    if (config.connection) {
+        if (!config.connection.url && !config.connection.host) {
+            errors.push('Connection requires either url or host');
+        }
+    }
+    if (config.migrations) {
+        if (!config.migrations.directory) {
+            errors.push('Migrations require a directory');
+        }
+    }
+    if (config.typeGeneration) {
+        if (!config.typeGeneration.output) {
+            errors.push('Type generation requires an output path');
+        }
+    }
+    if (config.pool) {
+        if (config.pool.min !== undefined && config.pool.max !== undefined) {
+            if (config.pool.min > config.pool.max) {
+                errors.push('Pool min cannot be greater than max');
+            }
+        }
+        if (config.pool.min !== undefined && config.pool.min < 0) {
+            errors.push('Pool min must be non-negative');
+        }
+        if (config.pool.max !== undefined && config.pool.max < 1) {
+            errors.push('Pool max must be at least 1');
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/cjs/config/index.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = exports.mergeConfigs = exports.parseConnectionUrl = exports.loadConfig = exports.defineConfig = void 0;
+var config_1 = require("./config.cjs");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return config_1.defineConfig; } });
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "parseConnectionUrl", { enumerable: true, get: function () { return config_1.parseConnectionUrl; } });
+Object.defineProperty(exports, "mergeConfigs", { enumerable: true, get: function () { return config_1.mergeConfigs; } });
+Object.defineProperty(exports, "validateConfig", { enumerable: true, get: function () { return config_1.validateConfig; } });

package/dist/cjs/constants/pg-values.cjs

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PG = exports.PgValue = exports.RawValue = void 0;
+class RawValue {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return this.value;
+    }
+}
+exports.RawValue = RawValue;
+class PgValue {
+    static NOW = new RawValue('NOW()');
+    static CURRENT_TIMESTAMP = new RawValue('CURRENT_TIMESTAMP');
+    static CURRENT_DATE = new RawValue('CURRENT_DATE');
+    static CURRENT_TIME = new RawValue('CURRENT_TIME');
+    static LOCALTIMESTAMP = new RawValue('LOCALTIMESTAMP');
+    static LOCALTIME = new RawValue('LOCALTIME');
+    static TRANSACTION_TIMESTAMP = new RawValue('transaction_timestamp()');
+    static STATEMENT_TIMESTAMP = new RawValue('statement_timestamp()');
+    static CLOCK_TIMESTAMP = new RawValue('clock_timestamp()');
+    static gen_random_uuid() {
+        return new RawValue('gen_random_uuid()');
+    }
+    static uuid_generate_v1() {
+        return new RawValue('uuid_generate_v1()');
+    }
+    static uuid_generate_v4() {
+        return new RawValue('uuid_generate_v4()');
+    }
+    static nextval(sequenceName) {
+        return new RawValue(`nextval('${sequenceName}')`);
+    }
+    static currval(sequenceName) {
+        return new RawValue(`currval('${sequenceName}')`);
+    }
+    static lastval() {
+        return new RawValue('lastval()');
+    }
+    static setval(sequenceName, value) {
+        return new RawValue(`setval('${sequenceName}', ${value})`);
+    }
+    static DEFAULT = new RawValue('DEFAULT');
+    static NULL = new RawValue('NULL');
+    static TRUE = new RawValue('TRUE');
+    static FALSE = new RawValue('FALSE');
+    static EMPTY_ARRAY = new RawValue('ARRAY[]::text[]');
+    static EMPTY_JSONB_OBJECT = new RawValue("'{}'::jsonb");
+    static EMPTY_JSONB_ARRAY = new RawValue("'[]'::jsonb");
+    static raw(sql) {
+        return new RawValue(sql);
+    }
+    static array(values, type = 'text') {
+        const formatted = values.map(v => `'${String(v).replace(/'/g, "''")}'`).join(',');
+        return new RawValue(`ARRAY[${formatted}]::${type}[]`);
+    }
+    static jsonb(obj) {
+        return new RawValue(`'${JSON.stringify(obj)}'::jsonb`);
+    }
+    static cast(value, type) {
+        const escaped = String(value).replace(/'/g, "''");
+        return new RawValue(`'${escaped}'::${type}`);
+    }
+}
+exports.PgValue = PgValue;
+exports.PG = PgValue;

package/dist/cjs/copy/copy-builder.cjs

@@ -0,0 +1,316 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyFromBuilder = exports.CopyToBuilder = void 0;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const relq_errors_1 = require("../errors/relq-errors.cjs");
+class CopyToBuilder {
+    tableName;
+    queryString;
+    columns = [];
+    destination = 'STDOUT';
+    options = {};
+    constructor(source) {
+        if (source) {
+            this.tableName = source;
+        }
+    }
+    table(tableName) {
+        this.tableName = tableName;
+        return this;
+    }
+    query(sql) {
+        this.queryString = sql;
+        this.tableName = undefined;
+        return this;
+    }
+    only(...columnNames) {
+        this.columns = columnNames;
+        return this;
+    }
+    toStdout() {
+        this.destination = 'STDOUT';
+        return this;
+    }
+    toFile(filename) {
+        this.destination = (0, pg_format_1.default)('%L', filename);
+        return this;
+    }
+    toProgram(command) {
+        this.destination = (0, pg_format_1.default)('PROGRAM %L', command);
+        return this;
+    }
+    csv() {
+        this.options.format = 'CSV';
+        return this;
+    }
+    binary() {
+        this.options.format = 'BINARY';
+        return this;
+    }
+    text() {
+        this.options.format = 'TEXT';
+        return this;
+    }
+    withFormat(fmt) {
+        this.options.format = fmt;
+        return this;
+    }
+    withHeader(value = true) {
+        this.options.header = value;
+        return this;
+    }
+    withDelimiter(delimiter) {
+        this.options.delimiter = delimiter;
+        return this;
+    }
+    withNull(nullString) {
+        this.options.null = nullString;
+        return this;
+    }
+    withQuote(quoteChar) {
+        this.options.quote = quoteChar;
+        return this;
+    }
+    withEscape(escapeChar) {
+        this.options.escape = escapeChar;
+        return this;
+    }
+    withEncoding(encoding) {
+        this.options.encoding = encoding;
+        return this;
+    }
+    forceQuote(columns) {
+        this.options.forceQuote = columns;
+        return this;
+    }
+    toString() {
+        const parts = ['COPY'];
+        if (this.queryString) {
+            parts.push(`(${this.queryString})`);
+        }
+        else if (this.tableName) {
+            parts.push((0, pg_format_1.default)('%I', this.tableName));
+            if (this.columns.length > 0) {
+                const cols = this.columns.map(c => (0, pg_format_1.default)('%I', c)).join(', ');
+                parts.push(`(${cols})`);
+            }
+        }
+        else {
+            throw new relq_errors_1.RelqBuilderError('COPY TO requires either a table name or query', { builder: 'CopyToBuilder', missing: 'source', hint: 'Use .table() or .query()' });
+        }
+        parts.push('TO');
+        parts.push(this.destination);
+        const optionsParts = this.buildOptions();
+        if (optionsParts.length > 0) {
+            parts.push(`WITH (${optionsParts.join(', ')})`);
+        }
+        return parts.join(' ');
+    }
+    buildOptions() {
+        const opts = [];
+        if (this.options.format) {
+            opts.push(`FORMAT ${this.options.format}`);
+        }
+        if (this.options.header !== undefined) {
+            if (this.options.header === 'MATCH') {
+                opts.push('HEADER MATCH');
+            }
+            else {
+                opts.push(`HEADER ${this.options.header ? 'TRUE' : 'FALSE'}`);
+            }
+        }
+        if (this.options.delimiter) {
+            opts.push((0, pg_format_1.default)('DELIMITER %L', this.options.delimiter));
+        }
+        if (this.options.null !== undefined) {
+            opts.push((0, pg_format_1.default)('NULL %L', this.options.null));
+        }
+        if (this.options.quote) {
+            opts.push((0, pg_format_1.default)('QUOTE %L', this.options.quote));
+        }
+        if (this.options.escape) {
+            opts.push((0, pg_format_1.default)('ESCAPE %L', this.options.escape));
+        }
+        if (this.options.encoding) {
+            opts.push((0, pg_format_1.default)('ENCODING %L', this.options.encoding));
+        }
+        if (this.options.forceQuote) {
+            if (this.options.forceQuote === '*') {
+                opts.push('FORCE_QUOTE *');
+            }
+            else {
+                const cols = this.options.forceQuote.map(c => (0, pg_format_1.default)('%I', c)).join(', ');
+                opts.push(`FORCE_QUOTE (${cols})`);
+            }
+        }
+        return opts;
+    }
+}
+exports.CopyToBuilder = CopyToBuilder;
+class CopyFromBuilder {
+    tableName;
+    columns = [];
+    source = 'STDIN';
+    options = {};
+    whereClause;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    only(...columnNames) {
+        this.columns = columnNames;
+        return this;
+    }
+    fromStdin() {
+        this.source = 'STDIN';
+        return this;
+    }
+    fromFile(filename) {
+        this.source = (0, pg_format_1.default)('%L', filename);
+        return this;
+    }
+    fromProgram(command) {
+        this.source = (0, pg_format_1.default)('PROGRAM %L', command);
+        return this;
+    }
+    csv() {
+        this.options.format = 'CSV';
+        return this;
+    }
+    binary() {
+        this.options.format = 'BINARY';
+        return this;
+    }
+    text() {
+        this.options.format = 'TEXT';
+        return this;
+    }
+    withFormat(fmt) {
+        this.options.format = fmt;
+        return this;
+    }
+    withHeader(value = true) {
+        this.options.header = value;
+        return this;
+    }
+    withDelimiter(delimiter) {
+        this.options.delimiter = delimiter;
+        return this;
+    }
+    withNull(nullString) {
+        this.options.null = nullString;
+        return this;
+    }
+    withDefault(defaultString) {
+        this.options.default = defaultString;
+        return this;
+    }
+    withQuote(quoteChar) {
+        this.options.quote = quoteChar;
+        return this;
+    }
+    withEscape(escapeChar) {
+        this.options.escape = escapeChar;
+        return this;
+    }
+    withEncoding(encoding) {
+        this.options.encoding = encoding;
+        return this;
+    }
+    freeze(value = true) {
+        this.options.freeze = value;
+        return this;
+    }
+    forceNotNull(columns) {
+        this.options.forceNotNull = columns;
+        return this;
+    }
+    forceNull(columns) {
+        this.options.forceNull = columns;
+        return this;
+    }
+    onError(action) {
+        this.options.onError = action;
+        return this;
+    }
+    logVerbosity(level) {
+        this.options.logVerbosity = level;
+        return this;
+    }
+    where(condition) {
+        this.whereClause = condition;
+        return this;
+    }
+    toString() {
+        const parts = ['COPY'];
+        parts.push((0, pg_format_1.default)('%I', this.tableName));
+        if (this.columns.length > 0) {
+            const cols = this.columns.map(c => (0, pg_format_1.default)('%I', c)).join(', ');
+            parts.push(`(${cols})`);
+        }
+        parts.push('FROM');
+        parts.push(this.source);
+        const optionsParts = this.buildOptions();
+        if (optionsParts.length > 0) {
+            parts.push(`WITH (${optionsParts.join(', ')})`);
+        }
+        if (this.whereClause) {
+            parts.push('WHERE');
+            parts.push(this.whereClause);
+        }
+        return parts.join(' ');
+    }
+    buildOptions() {
+        const opts = [];
+        if (this.options.format) {
+            opts.push(`FORMAT ${this.options.format}`);
+        }
+        if (this.options.freeze !== undefined) {
+            opts.push(`FREEZE ${this.options.freeze ? 'TRUE' : 'FALSE'}`);
+        }
+        if (this.options.header !== undefined) {
+            if (this.options.header === 'MATCH') {
+                opts.push('HEADER MATCH');
+            }
+            else {
+                opts.push(`HEADER ${this.options.header ? 'TRUE' : 'FALSE'}`);
+            }
+        }
+        if (this.options.delimiter) {
+            opts.push((0, pg_format_1.default)('DELIMITER %L', this.options.delimiter));
+        }
+        if (this.options.null !== undefined) {
+            opts.push((0, pg_format_1.default)('NULL %L', this.options.null));
+        }
+        if (this.options.default !== undefined) {
+            opts.push((0, pg_format_1.default)('DEFAULT %L', this.options.default));
+        }
+        if (this.options.quote) {
+            opts.push((0, pg_format_1.default)('QUOTE %L', this.options.quote));
+        }
+        if (this.options.escape) {
+            opts.push((0, pg_format_1.default)('ESCAPE %L', this.options.escape));
+        }
+        if (this.options.encoding) {
+            opts.push((0, pg_format_1.default)('ENCODING %L', this.options.encoding));
+        }
+        if (this.options.forceNotNull && this.options.forceNotNull.length > 0) {
+            const cols = this.options.forceNotNull.map(c => (0, pg_format_1.default)('%I', c)).join(', ');
+            opts.push(`FORCE_NOT_NULL (${cols})`);
+        }
+        if (this.options.forceNull && this.options.forceNull.length > 0) {
+            const cols = this.options.forceNull.map(c => (0, pg_format_1.default)('%I', c)).join(', ');
+            opts.push(`FORCE_NULL (${cols})`);
+        }
+        if (this.options.onError) {
+            opts.push(`ON_ERROR ${this.options.onError.toUpperCase()}`);
+        }
+        if (this.options.logVerbosity) {
+            opts.push(`LOG_VERBOSITY ${this.options.logVerbosity.toUpperCase()}`);
+        }
+        return opts;
+    }
+}
+exports.CopyFromBuilder = CopyFromBuilder;

package/dist/cjs/copy/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyFromBuilder = exports.CopyToBuilder = void 0;
+var copy_builder_1 = require("./copy-builder.cjs");
+Object.defineProperty(exports, "CopyToBuilder", { enumerable: true, get: function () { return copy_builder_1.CopyToBuilder; } });
+Object.defineProperty(exports, "CopyFromBuilder", { enumerable: true, get: function () { return copy_builder_1.CopyFromBuilder; } });