relq 1.0.0

package/dist/esm/core/typed-kuery-client.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,81 @@
+import format from "../../addons/pg-format.js";
+import { ConditionCollector, buildConditionsSQL, buildConditionSQL } from "../condition/condition-collector.js";
+export class CountBuilder {
+    tableName;
+    countGroups = [];
+    whereConditions = [];
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    group(name, callback, options) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        let aggregateFunction = 'COUNT';
+        let column;
+        if (options) {
+            if (options.distinct) {
+                aggregateFunction = 'COUNT_DISTINCT';
+                column = options.distinct;
+            }
+            else if (options.sum) {
+                aggregateFunction = 'SUM';
+                column = options.sum;
+            }
+            else if (options.avg) {
+                aggregateFunction = 'AVG';
+                column = options.avg;
+            }
+            else if (options.min) {
+                aggregateFunction = 'MIN';
+                column = options.min;
+            }
+            else if (options.max) {
+                aggregateFunction = 'MAX';
+                column = options.max;
+            }
+        }
+        this.countGroups.push({
+            name,
+            conditions: conditionBuilder.getConditions(),
+            aggregateFunction,
+            column
+        });
+        return this;
+    }
+    where(callback) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    toString() {
+        let selectColumns = [];
+        if (this.countGroups.length > 0) {
+            selectColumns = this.countGroups.map(group => this.buildGroupSQL(group));
+        }
+        else {
+            selectColumns.push('COUNT(*) AS count');
+        }
+        let query = format('SELECT %s FROM %I', selectColumns.join(', '), this.tableName);
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + buildConditionsSQL(this.whereConditions);
+        }
+        return query;
+    }
+    buildGroupSQL(group) {
+        const conditionsSQL = group.conditions.map(condition => buildConditionSQL(condition)).join(' AND ');
+        let aggregateColumn = '*';
+        if (group.column) {
+            aggregateColumn = group.aggregateFunction === 'COUNT_DISTINCT'
+                ? format('DISTINCT %I', group.column)
+                : format.ident(group.column);
+        }
+        const funcName = group.aggregateFunction === 'COUNT_DISTINCT' ? 'COUNT' : group.aggregateFunction;
+        if (group.conditions.length > 0) {
+            return format('%s(%s) FILTER (WHERE %s) AS %I', funcName, aggregateColumn, conditionsSQL, group.name);
+        }
+        else {
+            return format('%s(%s) AS %I', funcName, aggregateColumn, group.name);
+        }
+    }
+}

package/dist/esm/count/index.js

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

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

@@ -0,0 +1,82 @@
+import format from "../../addons/pg-format.js";
+import { SelectBuilder } from "../select/select-builder.js";
+import { InsertBuilder } from "../insert/insert-builder.js";
+import { UpdateBuilder } from "../update/update-builder.js";
+import { DeleteBuilder } from "../delete/delete-builder.js";
+export class CTEBuilder {
+    ctes = [];
+    recursiveFlag = false;
+    with(name, query, columns) {
+        this.ctes.push({
+            name,
+            query: typeof query === 'string' ? query : query.toString(),
+            columns
+        });
+        return this;
+    }
+    withRecursive(name, query, columns) {
+        this.recursiveFlag = true;
+        this.ctes.push({
+            name,
+            query,
+            columns
+        });
+        return this;
+    }
+    withMaterialized(name, query, columns) {
+        this.ctes.push({
+            name,
+            query: typeof query === 'string' ? query : query.toString(),
+            columns,
+            materialized: true
+        });
+        return this;
+    }
+    withNotMaterialized(name, query, columns) {
+        this.ctes.push({
+            name,
+            query: typeof query === 'string' ? query : query.toString(),
+            columns,
+            notMaterialized: true
+        });
+        return this;
+    }
+    select(columns) {
+        const builder = new SelectBuilder('__CTE__', columns);
+        return builder;
+    }
+    insert(tableName, data) {
+        return new InsertBuilder(tableName, data);
+    }
+    update(tableName, data) {
+        return new UpdateBuilder(tableName, data);
+    }
+    delete(tableName) {
+        return new DeleteBuilder(tableName);
+    }
+    buildCTEClause() {
+        if (this.ctes.length === 0)
+            return '';
+        const keyword = this.recursiveFlag ? 'WITH RECURSIVE' : 'WITH';
+        const cteStrings = this.ctes.map(cte => {
+            let str = format.ident(cte.name);
+            if (cte.columns && cte.columns.length > 0) {
+                str += ` (${cte.columns.map(c => format.ident(c)).join(', ')})`;
+            }
+            str += ' AS ';
+            if (cte.materialized) {
+                str += 'MATERIALIZED ';
+            }
+            else if (cte.notMaterialized) {
+                str += 'NOT MATERIALIZED ';
+            }
+            str += `(${cte.query})`;
+            return str;
+        });
+        return `${keyword} ${cteStrings.join(', ')}`;
+    }
+    toString(mainQuery) {
+        const cteClause = this.buildCTEClause();
+        return cteClause ? `${cteClause} ${mainQuery}` : mainQuery;
+    }
+}

package/dist/esm/cte/index.js

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

package/dist/esm/ddl/function.js

@@ -0,0 +1,45 @@
+export function createFunction(options) {
+    const { name, returns, language, as: funcType = 'function', parameters = [], body, volatility, security, schema, orReplace = true, cost, rows, parallel } = options;
+    const fullName = schema ? `"${schema}"."${name}"` : `"${name}"`;
+    const definition = {
+        name,
+        options: Object.freeze({ ...options }),
+        toSQL() {
+            const parts = [];
+            parts.push(`CREATE${orReplace ? ' OR REPLACE' : ''} ${funcType.toUpperCase()} ${fullName}`);
+            const paramStr = parameters.map(p => {
+                let param = '';
+                if (p.mode && p.mode !== 'in')
+                    param += `${p.mode.toUpperCase()} `;
+                param += `"${p.name}" ${p.type}`;
+                if (p.default)
+                    param += ` DEFAULT ${p.default}`;
+                return param;
+            }).join(', ');
+            parts.push(`(${paramStr})`);
+            if (funcType === 'function' && returns) {
+                parts.push(`RETURNS ${returns}`);
+            }
+            parts.push(`LANGUAGE ${language}`);
+            if (volatility)
+                parts.push(volatility.toUpperCase());
+            if (security === 'definer')
+                parts.push('SECURITY DEFINER');
+            if (cost)
+                parts.push(`COST ${cost}`);
+            if (rows)
+                parts.push(`ROWS ${rows}`);
+            if (parallel)
+                parts.push(`PARALLEL ${parallel.toUpperCase()}`);
+            const bodyText = typeof body === 'string' ? body : body.text;
+            parts.push(`AS $$\n${bodyText}\n$$`);
+            return parts.join('\n');
+        },
+        toDropSQL() {
+            const paramTypes = parameters.map(p => p.type).join(', ');
+            return `DROP ${funcType.toUpperCase()} IF EXISTS ${fullName}(${paramTypes})`;
+        }
+    };
+    return definition;
+}
+export default createFunction;

package/dist/esm/ddl/index.js

@@ -0,0 +1,2 @@
+export { sql } from "./sql.js";
+export { createFunction } from "./function.js";

package/dist/esm/ddl/sql.js

@@ -0,0 +1,51 @@
+export function sql(strings, ...values) {
+    let text = '';
+    const paramValues = [];
+    strings.forEach((str, i) => {
+        text += str;
+        if (i < values.length) {
+            const value = values[i];
+            if (value && typeof value === 'object' && '__raw' in value) {
+                text += value.__raw;
+            }
+            else {
+                paramValues.push(value);
+                text += `$${paramValues.length}`;
+            }
+        }
+    });
+    return {
+        text,
+        values: paramValues,
+        toString() {
+            let result = text;
+            for (let i = paramValues.length; i > 0; i--) {
+                const val = paramValues[i - 1];
+                const replacement = typeof val === 'string'
+                    ? `'${val.replace(/'/g, "''")}'`
+                    : String(val);
+                result = result.replace(`$${i}`, replacement);
+            }
+            return result;
+        },
+        toParameterized() {
+            return { text, values: [...paramValues] };
+        }
+    };
+}
+sql.raw = function (value) {
+    return { __raw: value };
+};
+sql.id = function (identifier) {
+    return { __raw: `"${identifier.replace(/"/g, '""')}"` };
+};
+sql.literal = function (value) {
+    if (value === null)
+        return { __raw: 'NULL' };
+    if (typeof value === 'boolean')
+        return { __raw: value ? 'TRUE' : 'FALSE' };
+    if (typeof value === 'number')
+        return { __raw: String(value) };
+    return { __raw: `'${String(value).replace(/'/g, "''")}'` };
+};
+export default sql;

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

@@ -0,0 +1,128 @@
+import format from "../../addons/pg-format.js";
+import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
+import { SelectBuilder } from "../select/select-builder.js";
+import { CountBuilder } from "../count/count-builder.js";
+export class DeleteBuilder {
+    tableName;
+    whereConditions = [];
+    returningClause;
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    where(callback) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    returning(columns) {
+        if (columns === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'columns',
+                columns: Array.isArray(columns) ? columns : [columns]
+            };
+        }
+        return this;
+    }
+    returningSelect(callback) {
+        const builder = new SelectBuilder(this.tableName);
+        const result = callback(builder);
+        if (result === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'select',
+                builder: result
+            };
+        }
+        return this;
+    }
+    returningCount(callback) {
+        const builder = new CountBuilder(this.tableName);
+        const result = callback(builder);
+        if (result === null) {
+            this.returningClause = undefined;
+        }
+        else {
+            this.returningClause = {
+                type: 'count',
+                builder: result
+            };
+        }
+        return this;
+    }
+    toString() {
+        let query = format('DELETE FROM %I', this.tableName);
+        if (this.whereConditions.length > 0) {
+            query += ' WHERE ' + buildConditionsSQL(this.whereConditions);
+        }
+        if (this.returningClause) {
+            query += this.buildReturningClause();
+        }
+        return query;
+    }
+    parseCountColumns(columnsStr) {
+        const columns = [];
+        let depth = 0;
+        let currentExpr = '';
+        let i = 0;
+        while (i < columnsStr.length) {
+            const char = columnsStr[i];
+            if (char === '(')
+                depth++;
+            else if (char === ')')
+                depth--;
+            else if (char === ',' && depth === 0) {
+                if (currentExpr.trim()) {
+                    columns.push(this.parseColumnExpr(currentExpr.trim()));
+                }
+                currentExpr = '';
+                i++;
+                continue;
+            }
+            currentExpr += char;
+            i++;
+        }
+        if (currentExpr.trim()) {
+            columns.push(this.parseColumnExpr(currentExpr.trim()));
+        }
+        return columns;
+    }
+    parseColumnExpr(expr) {
+        const asMatch = expr.match(/^(.+?)\s+AS\s+(.+)$/i);
+        if (!asMatch) {
+            return { name: 'count', expr };
+        }
+        const [, expression, alias] = asMatch;
+        const name = alias.replace(/^["']|["']$/g, '');
+        return { name, expr: expression.trim() };
+    }
+    buildReturningClause() {
+        if (!this.returningClause)
+            return '';
+        switch (this.returningClause.type) {
+            case 'columns':
+                return format(' RETURNING %I', this.returningClause.columns);
+            case 'select': {
+                const selectSQL = this.returningClause.builder.toString();
+                return ` RETURNING (${selectSQL})`;
+            }
+            case 'count': {
+                const countSQL = this.returningClause.builder.toString();
+                const selectMatch = countSQL.match(/^SELECT\s+(.+?)\s+FROM\s+(.+)$/is);
+                if (!selectMatch)
+                    return ` RETURNING (${countSQL})`;
+                const [, columnsStr, fromClause] = selectMatch;
+                const columns = this.parseCountColumns(columnsStr);
+                const jsonArgs = columns.map(({ name, expr }) => `${format('%L', name)}, ${expr}`).join(', ');
+                return ` RETURNING (SELECT json_build_object(${jsonArgs}) FROM ${fromClause})`;
+            }
+            default:
+                return '';
+        }
+    }
+}

package/dist/esm/delete/index.js

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