relq 1.0.0

package/dist/esm/config/config.js

@@ -0,0 +1,150 @@
+export 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,
+        },
+    };
+}
+export function loadConfig(path) {
+    const configPath = path || findConfigFile();
+    if (!configPath) {
+        return Promise.resolve(defineConfig({}));
+    }
+    return import(configPath).then(module => {
+        if (module.default) {
+            return module.default;
+        }
+        return defineConfig({});
+    }).catch(() => {
+        return defineConfig({});
+    });
+}
+function findConfigFile() {
+    return null;
+}
+export 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 };
+    }
+}
+export 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);
+}
+export 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/esm/config/index.js

@@ -0,0 +1 @@
+export { defineConfig, loadConfig, parseConnectionUrl, mergeConfigs, validateConfig, } from "./config.js";

package/dist/esm/constants/pg-values.js

@@ -0,0 +1,63 @@
+export class RawValue {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return this.value;
+    }
+}
+export 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}`);
+    }
+}
+export const PG = PgValue;

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

@@ -0,0 +1,308 @@
+import format from "../../addons/pg-format.js";
+import { RelqBuilderError } from "../errors/relq-errors.js";
+export 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 = format('%L', filename);
+        return this;
+    }
+    toProgram(command) {
+        this.destination = format('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(format('%I', this.tableName));
+            if (this.columns.length > 0) {
+                const cols = this.columns.map(c => format('%I', c)).join(', ');
+                parts.push(`(${cols})`);
+            }
+        }
+        else {
+            throw new 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(format('DELIMITER %L', this.options.delimiter));
+        }
+        if (this.options.null !== undefined) {
+            opts.push(format('NULL %L', this.options.null));
+        }
+        if (this.options.quote) {
+            opts.push(format('QUOTE %L', this.options.quote));
+        }
+        if (this.options.escape) {
+            opts.push(format('ESCAPE %L', this.options.escape));
+        }
+        if (this.options.encoding) {
+            opts.push(format('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 => format('%I', c)).join(', ');
+                opts.push(`FORCE_QUOTE (${cols})`);
+            }
+        }
+        return opts;
+    }
+}
+export 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 = format('%L', filename);
+        return this;
+    }
+    fromProgram(command) {
+        this.source = format('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(format('%I', this.tableName));
+        if (this.columns.length > 0) {
+            const cols = this.columns.map(c => format('%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(format('DELIMITER %L', this.options.delimiter));
+        }
+        if (this.options.null !== undefined) {
+            opts.push(format('NULL %L', this.options.null));
+        }
+        if (this.options.default !== undefined) {
+            opts.push(format('DEFAULT %L', this.options.default));
+        }
+        if (this.options.quote) {
+            opts.push(format('QUOTE %L', this.options.quote));
+        }
+        if (this.options.escape) {
+            opts.push(format('ESCAPE %L', this.options.escape));
+        }
+        if (this.options.encoding) {
+            opts.push(format('ENCODING %L', this.options.encoding));
+        }
+        if (this.options.forceNotNull && this.options.forceNotNull.length > 0) {
+            const cols = this.options.forceNotNull.map(c => format('%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 => format('%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;
+    }
+}

package/dist/esm/copy/index.js

@@ -0,0 +1 @@
+export { CopyToBuilder, CopyFromBuilder } from "./copy-builder.js";