relq 1.0.0

package/dist/esm/utils/case-converter.js

@@ -0,0 +1,55 @@
+export function convertCase(str, type) {
+    if (!str || typeof str !== 'string')
+        return str;
+    function toCamel(s) {
+        return s.split(/[_\s-]+/).filter(segment => segment.length > 0).map((segment, index) => {
+            if (index === 0)
+                return segment.charAt(0).toLowerCase() + segment.slice(1).toLowerCase();
+            return segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase();
+        }).join('').replace(/'/g, '');
+    }
+    function toPascal(s) {
+        return s.split(/[_\s-]+/).filter(segment => segment.length > 0).map(segment => {
+            return segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase();
+        }).join('').replace(/'/g, '');
+    }
+    function toSnake(s) {
+        return s.split(/[_\s-]+/).filter(segment => segment.length > 0).map(segment => {
+            return segment.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+        }).join('_').replace(/'/g, '');
+    }
+    switch (type) {
+        case 'snake2camel':
+            return /^[a-z0-9]+(_[a-z0-9]+)*$/.test(str)
+                ? str.split('_').map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join('')
+                : str;
+        case 'snake2pascal':
+            return /^[a-z0-9]+(_[a-z0-9]+)*$/.test(str)
+                ? str.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('')
+                : str;
+        case 'camel2snake':
+            return /^[a-z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(str)
+                ? str.replace(/([A-Z])/g, '_$1').toLowerCase()
+                : str;
+        case 'camel2pascal':
+            return /^[a-z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(str)
+                ? str.charAt(0).toUpperCase() + str.slice(1)
+                : str;
+        case 'pascal2snake':
+            return /^[A-Z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(str)
+                ? str.replace(/([A-Z])/g, (match, offset) => offset > 0 ? '_' + match : match).toLowerCase()
+                : str;
+        case 'pascal2camel':
+            return /^[A-Z][a-z0-9]*([A-Z][a-z0-9]*)*$/.test(str)
+                ? str.charAt(0).toLowerCase() + str.slice(1)
+                : str;
+        case '2camel':
+            return toCamel(str);
+        case '2pascal':
+            return toPascal(str);
+        case '2snake':
+            return toSnake(str);
+        default:
+            return str;
+    }
+}

package/dist/esm/utils/environment-detection.js

@@ -0,0 +1,113 @@
+export function detectEnvironment() {
+    const detected = [];
+    const hasProcess = typeof process !== 'undefined' && process.env !== undefined;
+    if (!hasProcess) {
+        return {
+            type: 'edge',
+            provider: 'cloudflare',
+            detected: ['NO_PROCESS_OBJECT'],
+            hasProcess: false
+        };
+    }
+    if (process.env.VERCEL || process.env.VERCEL_ENV) {
+        if (process.env.VERCEL)
+            detected.push('VERCEL');
+        if (process.env.VERCEL_ENV)
+            detected.push('VERCEL_ENV');
+        return {
+            type: 'serverless',
+            provider: 'vercel',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.AWS_LAMBDA_FUNCTION_NAME ||
+        process.env.AWS_EXECUTION_ENV ||
+        process.env.LAMBDA_TASK_ROOT) {
+        if (process.env.AWS_LAMBDA_FUNCTION_NAME)
+            detected.push('AWS_LAMBDA_FUNCTION_NAME');
+        if (process.env.AWS_EXECUTION_ENV)
+            detected.push('AWS_EXECUTION_ENV');
+        if (process.env.LAMBDA_TASK_ROOT)
+            detected.push('LAMBDA_TASK_ROOT');
+        return {
+            type: 'serverless',
+            provider: 'aws-lambda',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.NETLIFY || process.env.NETLIFY_DEV) {
+        if (process.env.NETLIFY)
+            detected.push('NETLIFY');
+        if (process.env.NETLIFY_DEV)
+            detected.push('NETLIFY_DEV');
+        return {
+            type: 'serverless',
+            provider: 'netlify',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.FUNCTION_NAME || process.env.FUNCTION_TARGET || process.env.GCP_PROJECT) {
+        if (process.env.FUNCTION_NAME)
+            detected.push('FUNCTION_NAME');
+        if (process.env.FUNCTION_TARGET)
+            detected.push('FUNCTION_TARGET');
+        if (process.env.GCP_PROJECT)
+            detected.push('GCP_PROJECT');
+        return {
+            type: 'serverless',
+            provider: 'google-cloud',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.AZURE_FUNCTIONS_ENVIRONMENT || process.env.WEBSITE_INSTANCE_ID) {
+        if (process.env.AZURE_FUNCTIONS_ENVIRONMENT)
+            detected.push('AZURE_FUNCTIONS_ENVIRONMENT');
+        if (process.env.WEBSITE_INSTANCE_ID)
+            detected.push('WEBSITE_INSTANCE_ID');
+        return {
+            type: 'serverless',
+            provider: 'azure',
+            detected,
+            hasProcess: true
+        };
+    }
+    if (process.env.CLOUDFLARE_WORKERS || process.env.CF_PAGES) {
+        if (process.env.CLOUDFLARE_WORKERS)
+            detected.push('CLOUDFLARE_WORKERS');
+        if (process.env.CF_PAGES)
+            detected.push('CF_PAGES');
+        return {
+            type: 'edge',
+            provider: 'cloudflare',
+            detected,
+            hasProcess: true
+        };
+    }
+    return {
+        type: 'traditional',
+        detected: [],
+        hasProcess: true
+    };
+}
+export function isServerless() {
+    return detectEnvironment().type === 'serverless';
+}
+export function isTraditional() {
+    return detectEnvironment().type === 'traditional';
+}
+export function isEdge() {
+    return detectEnvironment().type === 'edge';
+}
+export function getEnvironmentDescription(env) {
+    if (env.type === 'serverless') {
+        return `${env.provider} (serverless)`;
+    }
+    if (env.type === 'edge') {
+        return `${env.provider || 'edge'} runtime`;
+    }
+    return 'Traditional server';
+}

package/dist/esm/utils/index.js

@@ -0,0 +1,2 @@
+export { convertCase } from "./case-converter.js";
+export { default as format } from "../../addons/pg-format.js";

package/dist/esm/utils/pool-defaults.js

@@ -0,0 +1,100 @@
+import { detectEnvironment } from "./environment-detection.js";
+export function getSmartPoolDefaults() {
+    const env = detectEnvironment();
+    const baseConfig = {
+        min: 0,
+        idleTimeoutMillis: 10000,
+        connectionTimeoutMillis: 10000,
+        pool: false
+    };
+    if (env.type === 'serverless') {
+        return {
+            ...baseConfig,
+            max: 1,
+            idleTimeoutMillis: 1000,
+            recommendation: `Serverless environment detected (${env.provider}).\n` +
+                '   Using single connection mode (recommended).\n' +
+                '   If pooling enabled: min: 0, max: 1'
+        };
+    }
+    if (env.type === 'edge') {
+        return {
+            ...baseConfig,
+            max: 0,
+            recommendation: 'Edge runtime detected. PostgreSQL connections not supported.\n' +
+                '   Use query builder only: relq("table").select().toString()'
+        };
+    }
+    return {
+        ...baseConfig,
+        max: 10,
+        idleTimeoutMillis: 30000,
+        recommendation: 'Traditional server environment.\n' +
+            '   Pooling disabled by default (single client).\n' +
+            '   To enable pooling: new Relq(schema, { pool: true, ... })'
+    };
+}
+export function validatePoolConfig(config, env) {
+    const warnings = [];
+    const errors = [];
+    const min = config.min ?? 0;
+    const max = config.max ?? 10;
+    if (env.type === 'edge') {
+        errors.push('❌ Edge runtime detected (Cloudflare Workers/Deno Deploy).\n' +
+            '   PostgreSQL connections are not supported in edge runtimes.\n' +
+            '   \n' +
+            '   Options:\n' +
+            '   1. Use query builder only: relq("table").select().toString()\n' +
+            '   2. Use HTTP-based database (Supabase, Neon, Xata)\n' +
+            '   3. Deploy to traditional Node.js runtime');
+        return { valid: false, warnings, errors };
+    }
+    if (min > max) {
+        warnings.push(`⚠️  Pool min (${min}) is greater than max (${max}).\n` +
+            `   This is invalid. Min will be clamped to max (${max}).`);
+    }
+    if (env.type === 'serverless' && max > 1) {
+        warnings.push(`⚠️  Running in ${env.provider} with pool max: ${max}.\n` +
+            '   Each serverless function will create up to ' + max + ' connections.\n' +
+            '   With many concurrent functions, this can exhaust PostgreSQL connections.\n' +
+            '   \n' +
+            '   Recommended: pool: { min: 0, max: 1 }\n' +
+            '   \n' +
+            '   If you need connection pooling in serverless:\n' +
+            '   - Use PgBouncer or connection pooler\n' +
+            '   - Use Supabase (built-in pooling)\n' +
+            '   - Use Neon serverless driver');
+    }
+    if (env.type === 'traditional' && min > 5) {
+        warnings.push(`⚠️  Pool min set to ${min}. This keeps ${min} connections always open.\n` +
+            '   High min values waste resources when traffic is low.\n' +
+            '   \n' +
+            '   Recommended: min: 0 (connections created on demand)\n' +
+            '   Pool will scale up to max: ' + max + ' under load automatically.');
+    }
+    if (max > 20) {
+        warnings.push(`⚠️  Pool max set to ${max}. This is very high.\n` +
+            '   PostgreSQL connection limit is typically 100-200.\n' +
+            '   Multiple app instances × max connections can exhaust the database.\n' +
+            '   \n' +
+            '   Recommended: max: 10-20 per app instance');
+    }
+    return {
+        valid: errors.length === 0,
+        warnings,
+        errors
+    };
+}
+export function mergeWithDefaults(userConfig) {
+    const defaults = getSmartPoolDefaults();
+    return {
+        min: userConfig?.min ?? defaults.min,
+        max: userConfig?.max ?? defaults.max,
+        idleTimeoutMillis: userConfig?.idleTimeoutMillis ?? defaults.idleTimeoutMillis,
+        connectionTimeoutMillis: userConfig?.connectionTimeoutMillis ?? defaults.connectionTimeoutMillis,
+        recommendation: defaults.recommendation
+    };
+}
+export function formatPoolConfig(config) {
+    return `{ min: ${config.min}, max: ${config.max}, idleTimeout: ${config.idleTimeoutMillis}ms }`;
+}

package/dist/esm/utils/type-coercion.js

@@ -0,0 +1,110 @@
+const BIGINT_TYPES = new Set(['BIGINT', 'INT8', 'BIGSERIAL', 'SERIAL8']);
+const DATE_TYPES = new Set(['TIMESTAMP', 'TIMESTAMPTZ', 'DATE', 'TIME', 'TIMETZ']);
+const JSON_TYPES = new Set(['JSON', 'JSONB']);
+export function deserializeValue(value, pgType) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const upperType = pgType.toUpperCase();
+    if (BIGINT_TYPES.has(upperType)) {
+        if (typeof value === 'string') {
+            return BigInt(value);
+        }
+        if (typeof value === 'number') {
+            return BigInt(value);
+        }
+        return value;
+    }
+    if (DATE_TYPES.has(upperType) || upperType.startsWith('TIMESTAMP')) {
+        if (value instanceof Date) {
+            return value;
+        }
+        if (typeof value === 'string' || typeof value === 'number') {
+            return new Date(value);
+        }
+        return value;
+    }
+    if (JSON_TYPES.has(upperType)) {
+        if (typeof value === 'string') {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        }
+        return value;
+    }
+    if (upperType === 'BOOLEAN' || upperType === 'BOOL') {
+        if (typeof value === 'string') {
+            return value.toLowerCase() === 'true' || value === 't' || value === '1';
+        }
+        return Boolean(value);
+    }
+    return value;
+}
+export function deserializeRow(row, schema) {
+    const result = {};
+    const columnMap = new Map();
+    for (const [key, config] of Object.entries(schema)) {
+        const dbColumnName = config.$columnName || key;
+        columnMap.set(dbColumnName, { key, type: config.$type });
+    }
+    for (const [dbColumn, value] of Object.entries(row)) {
+        const mapping = columnMap.get(dbColumn);
+        if (mapping) {
+            result[mapping.key] = deserializeValue(value, mapping.type);
+        }
+        else {
+            result[dbColumn] = value;
+        }
+    }
+    return result;
+}
+export function deserializeRows(rows, schema) {
+    return rows.map(row => deserializeRow(row, schema));
+}
+export function serializeValue(value, pgType) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const upperType = pgType.toUpperCase();
+    if (BIGINT_TYPES.has(upperType)) {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        return value;
+    }
+    if (DATE_TYPES.has(upperType) || upperType.startsWith('TIMESTAMP')) {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        return value;
+    }
+    if (JSON_TYPES.has(upperType)) {
+        if (typeof value === 'object' && value !== null) {
+            return JSON.stringify(value);
+        }
+        return value;
+    }
+    return value;
+}
+export function serializeRow(row, schema) {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+        const config = schema[key];
+        if (config) {
+            result[key] = serializeValue(value, config.$type);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export function extractSchemaColumns(tableDefinition) {
+    if (tableDefinition && tableDefinition.$columns) {
+        return tableDefinition.$columns;
+    }
+    return null;
+}

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

@@ -0,0 +1,171 @@
+import format from "../../addons/pg-format.js";
+import { RelqBuilderError } from "../errors/relq-errors.js";
+export class CreateViewBuilder {
+    viewName;
+    query;
+    materializedFlag = false;
+    withDataFlag = true;
+    columnsAlias;
+    __checkOption;
+    securityBarrierFlag = false;
+    orReplaceFlag = false;
+    ifNotExistsFlag = false;
+    tablespaceValue;
+    withOptions = {};
+    constructor(viewName) {
+        this.viewName = viewName;
+    }
+    as(query) {
+        this.query = typeof query === 'string' ? query : query.toString();
+        return this;
+    }
+    materialized() {
+        this.materializedFlag = true;
+        return this;
+    }
+    withData() {
+        this.withDataFlag = true;
+        return this;
+    }
+    withNoData() {
+        this.withDataFlag = false;
+        return this;
+    }
+    columns(...names) {
+        this.columnsAlias = names;
+        return this;
+    }
+    checkOption(level) {
+        this.__checkOption = level;
+        return this;
+    }
+    securityBarrier() {
+        this.securityBarrierFlag = true;
+        return this;
+    }
+    orReplace() {
+        this.orReplaceFlag = true;
+        return this;
+    }
+    ifNotExists() {
+        this.ifNotExistsFlag = true;
+        return this;
+    }
+    tablespace(name) {
+        this.tablespaceValue = name;
+        return this;
+    }
+    with(options) {
+        this.withOptions = { ...this.withOptions, ...options };
+        return this;
+    }
+    toString() {
+        if (!this.query) {
+            throw new RelqBuilderError('View query is required', {
+                builder: 'CreateViewBuilder',
+                missing: 'query',
+                hint: 'Use .as() method to specify the view query'
+            });
+        }
+        let sql = 'CREATE';
+        if (this.orReplaceFlag && !this.materializedFlag) {
+            sql += ' OR REPLACE';
+        }
+        if (this.materializedFlag) {
+            sql += ' MATERIALIZED';
+        }
+        sql += ' VIEW';
+        if (this.ifNotExistsFlag) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${format.ident(this.viewName)}`;
+        if (this.columnsAlias && this.columnsAlias.length > 0) {
+            sql += ` (${this.columnsAlias.map(c => format.ident(c)).join(', ')})`;
+        }
+        if (!this.materializedFlag && Object.keys(this.withOptions).length > 0) {
+            const opts = Object.entries(this.withOptions)
+                .map(([k, v]) => `${k} = ${typeof v === 'boolean' ? (v ? 'true' : 'false') : v}`)
+                .join(', ');
+            sql += ` WITH (${opts})`;
+        }
+        if (this.tablespaceValue && this.materializedFlag) {
+            sql += ` TABLESPACE ${format.ident(this.tablespaceValue)}`;
+        }
+        sql += ` AS ${this.query}`;
+        if (this.materializedFlag) {
+            sql += this.withDataFlag ? ' WITH DATA' : ' WITH NO DATA';
+        }
+        if (!this.materializedFlag && this.__checkOption) {
+            sql += ` WITH ${this.__checkOption} CHECK OPTION`;
+        }
+        return sql;
+    }
+}
+export class DropViewBuilder {
+    viewName;
+    materializedFlag = false;
+    ifExistsFlag = false;
+    cascadeFlag = false;
+    constructor(viewName, materialized = false) {
+        this.viewName = viewName;
+        this.materializedFlag = materialized;
+    }
+    ifExists() {
+        this.ifExistsFlag = true;
+        return this;
+    }
+    cascade() {
+        this.cascadeFlag = true;
+        return this;
+    }
+    restrict() {
+        this.cascadeFlag = false;
+        return this;
+    }
+    toString() {
+        let sql = 'DROP';
+        if (this.materializedFlag) {
+            sql += ' MATERIALIZED';
+        }
+        sql += ' VIEW';
+        if (this.ifExistsFlag) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${format.ident(this.viewName)}`;
+        if (this.cascadeFlag) {
+            sql += ' CASCADE';
+        }
+        return sql;
+    }
+}
+export class RefreshMaterializedViewBuilder {
+    viewName;
+    concurrentlyFlag = false;
+    withDataFlag = true;
+    constructor(viewName) {
+        this.viewName = viewName;
+    }
+    concurrently() {
+        this.concurrentlyFlag = true;
+        return this;
+    }
+    withData() {
+        this.withDataFlag = true;
+        return this;
+    }
+    withNoData() {
+        this.withDataFlag = false;
+        return this;
+    }
+    toString() {
+        let sql = 'REFRESH MATERIALIZED VIEW';
+        if (this.concurrentlyFlag) {
+            sql += ' CONCURRENTLY';
+        }
+        sql += ` ${format.ident(this.viewName)}`;
+        if (!this.withDataFlag) {
+            sql += ' WITH NO DATA';
+        }
+        return sql;
+    }
+}

package/dist/esm/view/index.js

@@ -0,0 +1 @@
+export { CreateViewBuilder, DropViewBuilder, RefreshMaterializedViewBuilder } from "./create-view-builder.js";

package/dist/esm/window/index.js

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

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

@@ -0,0 +1,73 @@
+import format from "../../addons/pg-format.js";
+export class WindowBuilder {
+    partitionColumns = [];
+    orderColumns = [];
+    frameStart;
+    frameEnd;
+    frameMode;
+    partitionBy(...columns) {
+        this.partitionColumns.push(...columns);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderColumns.push({ column, direction });
+        return this;
+    }
+    rows(start, end) {
+        this.frameMode = 'ROWS';
+        this.frameStart = typeof start === 'number' ? `${start} PRECEDING` : start;
+        this.frameEnd = end ? (typeof end === 'number' ? `${end} FOLLOWING` : end) : 'CURRENT ROW';
+        return this;
+    }
+    range(start, end) {
+        this.frameMode = 'RANGE';
+        this.frameStart = typeof start === 'number' ? `${start} PRECEDING` : start;
+        this.frameEnd = end ? (typeof end === 'number' ? `${end} FOLLOWING` : end) : 'CURRENT ROW';
+        return this;
+    }
+    groups(start, end) {
+        this.frameMode = 'GROUPS';
+        this.frameStart = typeof start === 'number' ? `${start} PRECEDING` : start;
+        this.frameEnd = end ? (typeof end === 'number' ? `${end} FOLLOWING` : end) : 'CURRENT ROW';
+        return this;
+    }
+    toString() {
+        const parts = [];
+        if (this.partitionColumns.length > 0) {
+            parts.push(`PARTITION BY ${this.partitionColumns.map(c => format.ident(c)).join(', ')}`);
+        }
+        if (this.orderColumns.length > 0) {
+            parts.push(`ORDER BY ${this.orderColumns.map(o => `${format.ident(o.column)} ${o.direction}`).join(', ')}`);
+        }
+        if (this.frameMode && this.frameStart) {
+            parts.push(`${this.frameMode} BETWEEN ${this.frameStart} AND ${this.frameEnd}`);
+        }
+        return parts.join(' ');
+    }
+    rowNumber() {
+        return `ROW_NUMBER() OVER (${this.toString()})`;
+    }
+    rank() {
+        return `RANK() OVER (${this.toString()})`;
+    }
+    denseRank() {
+        return `DENSE_RANK() OVER (${this.toString()})`;
+    }
+    lag(column, offset = 1, defaultValue) {
+        const def = defaultValue !== undefined ? `, ${format('%L', defaultValue)}` : '';
+        return `LAG(${format.ident(column)}, ${offset}${def}) OVER (${this.toString()})`;
+    }
+    lead(column, offset = 1, defaultValue) {
+        const def = defaultValue !== undefined ? `, ${format('%L', defaultValue)}` : '';
+        return `LEAD(${format.ident(column)}, ${offset}${def}) OVER (${this.toString()})`;
+    }
+    firstValue(column) {
+        return `FIRST_VALUE(${format.ident(column)}) OVER (${this.toString()})`;
+    }
+    lastValue(column) {
+        return `LAST_VALUE(${format.ident(column)}) OVER (${this.toString()})`;
+    }
+    nthValue(column, n) {
+        return `NTH_VALUE(${format.ident(column)}, ${n}) OVER (${this.toString()})`;
+    }
+}

package/dist/index.cjs

@@ -0,0 +1 @@
+module.exports = require('./cjs/index.cjs');