relq 1.0.36 → 1.0.38

package/dist/cjs/cli/commands/pull.cjs

@@ -574,7 +574,7 @@ async function pullCommand(context) {
                     const hasTypesImport = typesImportPattern.test(schemaContent);
                     const typesWithUsages = typesForProgress.filter(t => t.usages && t.usages.length > 0);
                     if (typesWithUsages.length > 0 && !hasTypesImport) {
-                        console.log(`Applying ${typesWithUsages.length} type(s) to schema...`);
+                        spinner.start(`Applying ${typesWithUsages.length} type(s) to schema...`);
                         const columnTypeMap = {};
                         for (const typeDef of typesForProgress) {
                             if (typeDef.usages) {
@@ -595,7 +595,7 @@ async function pullCommand(context) {
                             typesImportPath,
                         });
                         fs.writeFileSync(schemaPath, typescript, 'utf-8');
-                        console.log(`Updated ${cli_utils_1.colors.cyan(schemaPath)} with type annotations`);
+                        spinner.succeed(`Updated ${cli_utils_1.colors.cyan(schemaPath)} with type annotations`);
                         hasSynced = true;
                     }
                 }

package/dist/cjs/cli/utils/ast-codegen.cjs

@@ -819,7 +819,7 @@ function generateTypeScriptFromAST(schema, options = {}) {
     const usedTypeNames = new Set(Object.values(columnTypeMap));
     if (usedTypeNames.size > 0 && typesImportPath) {
         const typeNames = Array.from(usedTypeNames).sort();
-        parts.push(`import { ${typeNames.join(', ')} } from '${typesImportPath}';`);
+        parts.push(`import type { ${typeNames.join(', ')} } from '${typesImportPath}';`);
     }
     parts.push('');
     if (needsPgExtensions) {

package/dist/cjs/condition/condition-collector.cjs

@@ -178,6 +178,13 @@ class ConditionCollector {
     }
 }
 exports.ConditionCollector = ConditionCollector;
+function formatColumn(column) {
+    if (column.includes('.')) {
+        const parts = column.split('.');
+        return parts.map(p => pg_format_1.default.ident(p)).join('.');
+    }
+    return pg_format_1.default.ident(column);
+}
 function buildConditionSQL(condition) {
     const { method, column, values } = condition;
     if (method.startsWith('jsonb_')) {
@@ -198,73 +205,74 @@ function buildConditionSQL(condition) {
     if (method.startsWith('network_')) {
         return (0, network_condition_builder_1.buildNetworkConditionSQL)(condition);
     }
+    const col = column ? formatColumn(column) : '';
     switch (method) {
         case 'equal':
             if (Array.isArray(values) && values.length > 1) {
-                return (0, pg_format_1.default)('%I IN %L', column, values);
+                return `${col} IN ${(0, pg_format_1.default)('%L', values)}`;
             }
-            return (0, pg_format_1.default)('%I = %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} = ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'notEqual':
             if (Array.isArray(values) && values.length > 1) {
-                return (0, pg_format_1.default)('%I NOT IN %L', column, values);
+                return `${col} NOT IN ${(0, pg_format_1.default)('%L', values)}`;
             }
-            return (0, pg_format_1.default)('%I != %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} != ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'lessThan':
-            return (0, pg_format_1.default)('%I < %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} < ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'lessThanEqual':
-            return (0, pg_format_1.default)('%I <= %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} <= ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'greaterThan':
-            return (0, pg_format_1.default)('%I > %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} > ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'greaterThanEqual':
-            return (0, pg_format_1.default)('%I >= %L', column, Array.isArray(values) ? values[0] : values);
+            return `${col} >= ${(0, pg_format_1.default)('%L', Array.isArray(values) ? values[0] : values)}`;
         case 'isNull':
-            return (0, pg_format_1.default)('%I IS NULL', column);
+            return `${col} IS NULL`;
         case 'isNotNull':
-            return (0, pg_format_1.default)('%I IS NOT NULL', column);
+            return `${col} IS NOT NULL`;
         case 'between': {
             const [start, end] = values;
-            return (0, pg_format_1.default)('%I BETWEEN %L AND %L', column, start, end);
+            return `${col} BETWEEN ${(0, pg_format_1.default)('%L', start)} AND ${(0, pg_format_1.default)('%L', end)}`;
         }
         case 'notBetween': {
             const [notStart, notEnd] = values;
-            return (0, pg_format_1.default)('%I NOT BETWEEN %L AND %L', column, notStart, notEnd);
+            return `${col} NOT BETWEEN ${(0, pg_format_1.default)('%L', notStart)} AND ${(0, pg_format_1.default)('%L', notEnd)}`;
         }
         case 'startsWith':
-            return (0, pg_format_1.default)('%I LIKE %L', column, `${values}%`);
+            return `${col} LIKE ${(0, pg_format_1.default)('%L', `${values}%`)}`;
         case 'notStartsWith':
-            return (0, pg_format_1.default)('%I NOT LIKE %L', column, `${values}%`);
+            return `${col} NOT LIKE ${(0, pg_format_1.default)('%L', `${values}%`)}`;
         case 'endsWith':
-            return (0, pg_format_1.default)('%I LIKE %L', column, `%${values}`);
+            return `${col} LIKE ${(0, pg_format_1.default)('%L', `%${values}`)}`;
         case 'notEndsWith':
-            return (0, pg_format_1.default)('%I NOT LIKE %L', column, `%${values}`);
+            return `${col} NOT LIKE ${(0, pg_format_1.default)('%L', `%${values}`)}`;
         case 'contains':
-            return (0, pg_format_1.default)('%I LIKE %L', column, `%${values}%`);
+            return `${col} LIKE ${(0, pg_format_1.default)('%L', `%${values}%`)}`;
         case 'notContains':
-            return (0, pg_format_1.default)('%I NOT LIKE %L', column, `%${values}%`);
+            return `${col} NOT LIKE ${(0, pg_format_1.default)('%L', `%${values}%`)}`;
         case 'like':
-            return (0, pg_format_1.default)('%I LIKE %L', column, values);
+            return `${col} LIKE ${(0, pg_format_1.default)('%L', values)}`;
         case 'notLike':
-            return (0, pg_format_1.default)('%I NOT LIKE %L', column, values);
+            return `${col} NOT LIKE ${(0, pg_format_1.default)('%L', values)}`;
         case 'ilike':
-            return (0, pg_format_1.default)('%I ILIKE %L', column, values);
+            return `${col} ILIKE ${(0, pg_format_1.default)('%L', values)}`;
         case 'in': {
             const valueList = Array.isArray(values) ? values : [values];
             const formattedValues = valueList.map(v => (0, pg_format_1.default)('%L', v)).join(', ');
-            return (0, pg_format_1.default)('%I IN (%s)', column, formattedValues);
+            return `${col} IN (${formattedValues})`;
         }
         case 'notIn': {
             const valueList = Array.isArray(values) ? values : [values];
             const formattedValues = valueList.map(v => (0, pg_format_1.default)('%L', v)).join(', ');
-            return (0, pg_format_1.default)('%I NOT IN (%s)', column, formattedValues);
+            return `${col} NOT IN (${formattedValues})`;
         }
         case 'exists':
-            return (0, pg_format_1.default)('EXISTS (%s)', values);
+            return `EXISTS (${values})`;
         case 'notExists':
-            return (0, pg_format_1.default)('NOT EXISTS (%s)', values);
+            return `NOT EXISTS (${values})`;
         case 'search':
-            return (0, pg_format_1.default)('to_tsvector(%I) @@ plainto_tsquery(%L)', column, values);
+            return `to_tsvector(${col}) @@ plainto_tsquery(${(0, pg_format_1.default)('%L', values)})`;
         case 'notSearch':
-            return (0, pg_format_1.default)('NOT (to_tsvector(%I) @@ plainto_tsquery(%L))', column, values);
+            return `NOT (to_tsvector(${col}) @@ plainto_tsquery(${(0, pg_format_1.default)('%L', values)}))`;
         case 'or': {
             const orConditions = values;
             return `(${orConditions.map(c => buildConditionSQL(c)).join(' OR ')})`;

package/dist/cjs/core/helpers/ConnectedAggregateBuilder.cjs

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedAggregateBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+class ConnectedAggregateBuilder {
+    builder;
+    relq;
+    tableName;
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    mapColumn(column) {
+        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [column]: true });
+        return Object.keys(transformed)[0] || column;
+    }
+    groupBy(...columns) {
+        const dbColumns = columns.map(col => this.mapColumn(col));
+        this.builder.groupBy(...dbColumns);
+        return this;
+    }
+    count(alias) {
+        this.builder.count(alias);
+        return this;
+    }
+    countColumn(column, alias) {
+        this.builder.countColumn(this.mapColumn(column), alias);
+        return this;
+    }
+    countDistinct(column, alias) {
+        this.builder.countDistinct(this.mapColumn(column), alias);
+        return this;
+    }
+    sum(column, alias) {
+        this.builder.sum(this.mapColumn(column), alias);
+        return this;
+    }
+    avg(column, alias) {
+        this.builder.avg(this.mapColumn(column), alias);
+        return this;
+    }
+    min(column, alias) {
+        this.builder.min(this.mapColumn(column), alias);
+        return this;
+    }
+    max(column, alias) {
+        this.builder.max(this.mapColumn(column), alias);
+        return this;
+    }
+    arrayAgg(column, alias) {
+        this.builder.arrayAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    stringAgg(column, delimiter, alias) {
+        this.builder.stringAgg(this.mapColumn(column), delimiter || ', ', alias);
+        return this;
+    }
+    jsonAgg(column, alias) {
+        this.builder.jsonAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    jsonbAgg(column, alias) {
+        this.builder.jsonbAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    boolAnd(column, alias) {
+        this.builder.boolAnd(this.mapColumn(column), alias);
+        return this;
+    }
+    boolOr(column, alias) {
+        this.builder.boolOr(this.mapColumn(column), alias);
+        return this;
+    }
+    where(callback) {
+        this.builder.where(callback);
+        return this;
+    }
+    having(callback) {
+        this.builder.having(callback);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.builder.orderBy(this.mapColumn(column), direction);
+        return this;
+    }
+    limit(count) {
+        this.builder.limit(count);
+        return this;
+    }
+    offset(count) {
+        this.builder.offset(count);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async all() {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelect(sql, this.tableName);
+        const numericAliases = this.builder.getNumericAliases();
+        if (numericAliases.length > 0) {
+            for (const row of result.data) {
+                for (const alias of numericAliases) {
+                    if (alias in row && typeof row[alias] === 'string') {
+                        row[alias] = Number(row[alias]);
+                    }
+                }
+            }
+        }
+        return result.data;
+    }
+    async get() {
+        this.builder.limit(1);
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelectOne(sql, this.tableName);
+        const numericAliases = this.builder.getNumericAliases();
+        if (numericAliases.length > 0 && result.data) {
+            for (const alias of numericAliases) {
+                if (alias in result.data && typeof result.data[alias] === 'string') {
+                    result.data[alias] = Number(result.data[alias]);
+                }
+            }
+        }
+        return result.data;
+    }
+}
+exports.ConnectedAggregateBuilder = ConnectedAggregateBuilder;

package/dist/cjs/core/helpers/ConnectedCTEBuilder.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedCTEBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+class ConnectedCTEBuilder {
+    relq;
+    ctes = [];
+    constructor(relq) {
+        this.relq = relq;
+    }
+    with(name, query) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        this.ctes.push({ name, query: queryStr });
+        return this;
+    }
+    withMaterialized(name, query) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        this.ctes.push({ name, query: `MATERIALIZED (${queryStr})` });
+        return this;
+    }
+    async query(sql) {
+        const cteClause = this.buildCTEClause();
+        const fullSql = `${cteClause} ${sql}`;
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(fullSql);
+        return {
+            data: result.result.rows,
+            rowCount: result.result.rowCount ?? 0
+        };
+    }
+    async all(sql) {
+        const result = await this.query(sql);
+        return result.data;
+    }
+    async get(sql) {
+        const result = await this.query(sql);
+        return result.data[0] ?? null;
+    }
+    buildCTEClause() {
+        if (this.ctes.length === 0)
+            return '';
+        const cteStrings = this.ctes.map(cte => {
+            if (cte.query.startsWith('MATERIALIZED')) {
+                return `"${cte.name}" AS ${cte.query}`;
+            }
+            return `"${cte.name}" AS (${cte.query})`;
+        });
+        return `WITH ${cteStrings.join(', ')}`;
+    }
+    toSQL(mainQuery) {
+        return `${this.buildCTEClause()} ${mainQuery}`;
+    }
+}
+exports.ConnectedCTEBuilder = ConnectedCTEBuilder;

package/dist/cjs/core/helpers/ConnectedCountBuilder.cjs

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedCountBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+class ConnectedCountBuilder {
+    builder;
+    relq;
+    tableName;
+    groupNames = [];
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    group(name, callback, options) {
+        this.groupNames.push(name);
+        this.builder.group(name, (q) => {
+            const wrapped = this.wrapConditionBuilder(q);
+            return callback(wrapped);
+        }, options);
+        return this;
+    }
+    where(callback) {
+        this.builder.where((q) => {
+            const wrapped = this.wrapConditionBuilder(q);
+            return callback(wrapped);
+        });
+        return this;
+    }
+    wrapConditionBuilder(originalBuilder) {
+        const relq = this.relq;
+        const tableName = this.tableName;
+        return new Proxy(originalBuilder, {
+            get(target, prop) {
+                const original = target[prop];
+                if (typeof original === 'function') {
+                    return function (column, ...args) {
+                        const transformed = relq[methods_1.INTERNAL].transformToDbColumns(tableName, { [column]: true });
+                        const dbColumn = Object.keys(transformed)[0] || column;
+                        return original.call(target, dbColumn, ...args);
+                    };
+                }
+                return original;
+            }
+        });
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async execute() {
+        const sql = this.builder.toString();
+        return this.relq[methods_1.INTERNAL].executeCount(sql);
+    }
+    async get() {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(sql);
+        const row = result.result.rows[0];
+        if (this.groupNames.length === 0) {
+            return (Number(row?.count) ?? 0);
+        }
+        const counts = {};
+        for (const name of this.groupNames) {
+            counts[name] = Number(row?.[name] ?? 0);
+        }
+        return counts;
+    }
+}
+exports.ConnectedCountBuilder = ConnectedCountBuilder;

package/dist/cjs/core/helpers/ConnectedDeleteBuilder.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedDeleteBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
+class ConnectedDeleteBuilder {
+    builder;
+    relq;
+    constructor(builder, relq) {
+        this.builder = builder;
+        this.relq = relq;
+    }
+    where(callback) {
+        this.builder.where(callback);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+    returning(columns) {
+        this.builder.returning(columns);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq);
+    }
+}
+exports.ConnectedDeleteBuilder = ConnectedDeleteBuilder;

package/dist/cjs/core/helpers/ConnectedInsertBuilder.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedInsertBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
+class ConnectedInsertBuilder {
+    builder;
+    relq;
+    constructor(builder, relq) {
+        this.builder = builder;
+        this.relq = relq;
+    }
+    addRow(row) {
+        this.builder.addRow(row);
+        return this;
+    }
+    addRows(rows) {
+        this.builder.addRows(rows);
+        return this;
+    }
+    clear() {
+        this.builder.clear();
+        return this;
+    }
+    get total() {
+        return this.builder.total;
+    }
+    onConflict(columns, callback) {
+        const cols = Array.isArray(columns) ? columns : [columns];
+        this.builder.onConflict(cols, (conflictBuilder) => {
+            callback(conflictBuilder);
+        });
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        (0, methods_1.debugLog)(this.relq[methods_1.INTERNAL]?.config, `ConnectedInsertBuilder.run called for table: ${this.builder.tableName}`);
+        const internalRelq = this.relq[methods_1.INTERNAL];
+        for (const row of this.builder.insertData) {
+            internalRelq.validateData(this.builder.tableName, row, 'insert');
+        }
+        const sql = this.builder.toString();
+        const result = await internalRelq.executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+    returning(columns) {
+        this.builder.returning(columns);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq);
+    }
+}
+exports.ConnectedInsertBuilder = ConnectedInsertBuilder;