@relq/orm 0.1.3 → 0.1.5

package/dist/cjs/addon/pg.cjs

@@ -367,9 +367,10 @@ var require_postgres_interval = __commonJS((exports2, module2) => {
 
 // node_modules/postgres-bytea/index.js
 var require_postgres_bytea = __commonJS((exports2, module2) => {
+  var bufferFrom = Buffer.from || Buffer;
   module2.exports = function parseBytea(input) {
     if (/^\\x/.test(input)) {
-      return new Buffer(input.substr(2), "hex");
+      return bufferFrom(input.substr(2), "hex");
     }
     var output = "";
     var i = 0;
@@ -393,7 +394,7 @@ var require_postgres_bytea = __commonJS((exports2, module2) => {
         }
       }
     }
-    return new Buffer(output, "binary");
+    return bufferFrom(output, "binary");
   };
 });
 
@@ -4935,14 +4936,14 @@ var require_lib2 = __commonJS((exports2, module2) => {
   });
 });
 
-// src/orm/utils/addon/pg/pg.ts
+// src/orm/pg/utils/addon/pg/pg.ts
 var exports_pg = {};
 __export(exports_pg, {
   types: () => types,
   escapeLiteral: () => escapeLiteral,
   escapeIdentifier: () => escapeIdentifier,
   defaults: () => defaults,
-  default: () => esm_default,
+  default: () => import_pg.default,
   TypeOverrides: () => TypeOverrides,
   Result: () => Result,
   Query: () => Query,
@@ -4966,4 +4967,3 @@ var escapeLiteral = import_lib.default.escapeLiteral;
 var Result = import_lib.default.Result;
 var TypeOverrides = import_lib.default.TypeOverrides;
 var defaults = import_lib.default.defaults;
-var esm_default = import_lib.default;

package/dist/cjs/cache/query-cache.cjs

@@ -149,7 +149,6 @@ class QueryCache {
         if (this.cache.size === 0)
             return;
         let keyToEvict;
-        let entryToEvict;
         switch (this.options.strategy) {
             case 'lru':
                 keyToEvict = this.cache.keys().next().value;
@@ -160,7 +159,6 @@ class QueryCache {
                     if (entry.createdAt < oldestTime) {
                         oldestTime = entry.createdAt;
                         keyToEvict = key;
-                        entryToEvict = entry;
                     }
                 });
                 break;
@@ -170,7 +168,6 @@ class QueryCache {
                     if (entry.size > largestSize) {
                         largestSize = entry.size;
                         keyToEvict = key;
-                        entryToEvict = entry;
                     }
                 });
                 break;
@@ -285,7 +282,7 @@ function createQueryCacheMiddleware(options) {
         }
     };
 }
-function withCache(cache, key, fn, ttl) {
+function withCache(cache, key, fn, _ttl) {
     const cached = cache.get(key);
     if (cached !== undefined) {
         return cached;

package/dist/cjs/core/cte/cte-accessor.cjs

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CTERefBuilder = void 0;
+exports.createCTEAccessor = createCTEAccessor;
+class CTERefBuilder {
+    cteName;
+    dialect;
+    resolveColumn;
+    selectedColumns = [];
+    whereConditions = [];
+    orderByClauses = [];
+    limitCount;
+    _sourceTableKey;
+    constructor(cteName, dialect, resolveColumn = (c) => c, sourceTableKey) {
+        this.cteName = cteName;
+        this.dialect = dialect;
+        this.resolveColumn = resolveColumn;
+        this._sourceTableKey = sourceTableKey;
+    }
+    select(...columns) {
+        this.selectedColumns = columns.map(c => this.resolveColumn(c));
+        return this;
+    }
+    where(callback) {
+        const collector = this.dialect.createCollector();
+        callback(collector);
+        const conditions = collector.getConditions();
+        this.whereConditions.push(...this.transformConditions(conditions));
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderByClauses.push(`${this.dialect.quoteIdent(this.resolveColumn(column))} ${direction}`);
+        return this;
+    }
+    limit(count) {
+        this.limitCount = count;
+        return this;
+    }
+    toString() {
+        const q = this.dialect.quoteIdent;
+        const cols = this.selectedColumns.length > 0
+            ? this.selectedColumns.map(c => q(c)).join(', ')
+            : '*';
+        let sql = `SELECT ${cols} FROM ${q(this.cteName)}`;
+        if (this.whereConditions.length > 0) {
+            sql += ` WHERE ${this.dialect.buildConditionsSQL(this.whereConditions)}`;
+        }
+        if (this.orderByClauses.length > 0) {
+            sql += ` ORDER BY ${this.orderByClauses.join(', ')}`;
+        }
+        if (this.limitCount !== undefined) {
+            sql += ` LIMIT ${this.limitCount}`;
+        }
+        return sql;
+    }
+    transformConditions(conditions) {
+        return conditions.map((cond) => {
+            if (!cond.column)
+                return cond;
+            if (cond.method === 'or' || cond.method === 'and' || cond.method === 'not') {
+                return { ...cond, values: this.transformConditions(cond.values) };
+            }
+            return { ...cond, column: this.resolveColumn(cond.column) };
+        });
+    }
+}
+exports.CTERefBuilder = CTERefBuilder;
+function createCTEAccessor(cteNames, dialect, cteMetas) {
+    return new Proxy({}, {
+        get(_, prop) {
+            if (typeof prop === 'symbol')
+                return undefined;
+            if (!cteNames.has(prop)) {
+                throw new Error(`CTE "${prop}" is not defined. Available CTEs: ${[...cteNames].join(', ')}.`);
+            }
+            const meta = cteMetas?.get(prop);
+            return new CTERefBuilder(prop, dialect, meta?.columnResolver || ((c) => c), meta?.sourceTableKey);
+        }
+    });
+}

package/dist/cjs/core/cte/cte-types.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPgCTEDialect = createPgCTEDialect;
+exports.createMysqlCTEDialect = createMysqlCTEDialect;
+function createPgCTEDialect() {
+    const { ConditionCollector, buildConditionsSQL } = require("../../pg/condition/condition-collector.cjs");
+    return {
+        quoteIdent: (name) => `"${name}"`,
+        supportsMaterialized: true,
+        supportsRecursive: true,
+        createCollector: () => new ConditionCollector(),
+        buildConditionsSQL: (conditions) => buildConditionsSQL(conditions),
+    };
+}
+function createMysqlCTEDialect() {
+    const { MysqlConditionCollector, buildMysqlConditionsSQL } = require("../../mysql/condition/condition-collector.cjs");
+    return {
+        quoteIdent: (name) => `\`${name}\``,
+        supportsMaterialized: false,
+        supportsRecursive: true,
+        createCollector: () => new MysqlConditionCollector(),
+        buildConditionsSQL: (conditions) => buildMysqlConditionsSQL(conditions),
+    };
+}

package/dist/cjs/core/cte/native-cte-builder.cjs

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeCTEBuilder = void 0;
+const cte_accessor_1 = require("./cte-accessor.cjs");
+const methods_1 = require("../helpers/methods.cjs");
+const relq_errors_1 = require("../../shared/errors/relq-errors.cjs");
+class CTEFromQuery {
+    cteName;
+    cteDefinitions;
+    dialect;
+    relq;
+    selectedColumns = [];
+    whereConditions = [];
+    orderByClauses = [];
+    limitCount;
+    offsetCount;
+    sourceTableKey;
+    numericAliases;
+    constructor(cteName, cteDefinitions, dialect, relq) {
+        this.cteName = cteName;
+        this.cteDefinitions = cteDefinitions;
+        this.dialect = dialect;
+        this.relq = relq;
+        const cteDef = cteDefinitions.find(c => c.name === cteName);
+        this.sourceTableKey = cteDef?.sourceTableKey;
+        this.numericAliases = cteDef?.numericAliases;
+    }
+    select(...columns) {
+        this.selectedColumns = columns.map(c => this.resolveColumn(c));
+        return this;
+    }
+    where(callback) {
+        const collector = this.dialect.createCollector();
+        callback(collector);
+        const conditions = collector.getConditions();
+        this.whereConditions.push(...this.transformConditions(conditions));
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        const dbCol = this.resolveColumn(column);
+        this.orderByClauses.push(`${this.dialect.quoteIdent(dbCol)} ${direction}`);
+        return this;
+    }
+    resolveColumn(propName) {
+        if (!this.sourceTableKey)
+            return propName;
+        try {
+            const mapped = this.relq[methods_1.INTERNAL].transformToDbColumns(this.sourceTableKey, { [propName]: true });
+            const keys = Object.keys(mapped);
+            return keys.length > 0 ? keys[0] : propName;
+        }
+        catch {
+            return propName;
+        }
+    }
+    transformConditions(conditions) {
+        if (!this.sourceTableKey)
+            return conditions;
+        return conditions.map((cond) => {
+            if (!cond.column)
+                return cond;
+            if (cond.method === 'or' || cond.method === 'and' || cond.method === 'not') {
+                return { ...cond, values: this.transformConditions(cond.values) };
+            }
+            return { ...cond, column: this.resolveColumn(cond.column) };
+        });
+    }
+    limit(count) {
+        this.limitCount = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetCount = count;
+        return this;
+    }
+    toString() {
+        return `${this.buildWithClause()} ${this.buildMainQuery()}`;
+    }
+    async all(withMetadata) {
+        const sql = this.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelect(sql, this.sourceTableKey);
+        this.coerceNumericResults(result.data);
+        if (withMetadata)
+            return { data: result.data, metadata: result.metadata };
+        return result.data;
+    }
+    async get(withMetadata) {
+        const sql = this.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelectOne(sql, this.sourceTableKey);
+        if (result.data)
+            this.coerceNumericResults([result.data]);
+        if (withMetadata)
+            return { data: result.data, metadata: result.metadata };
+        return result.data;
+    }
+    coerceNumericResults(rows) {
+        if (!this.numericAliases || this.numericAliases.length === 0)
+            return;
+        for (const row of rows) {
+            if (!row)
+                continue;
+            for (const alias of this.numericAliases) {
+                if (alias in row && typeof row[alias] === 'string') {
+                    row[alias] = Number(row[alias]);
+                }
+            }
+        }
+    }
+    buildWithClause() {
+        if (this.cteDefinitions.length === 0)
+            return '';
+        const hasRecursive = this.cteDefinitions.some(c => c.recursive);
+        const keyword = hasRecursive ? 'WITH RECURSIVE' : 'WITH';
+        const q = this.dialect.quoteIdent;
+        const parts = this.cteDefinitions.map(cte => {
+            const name = q(cte.name);
+            if (cte.materialized && this.dialect.supportsMaterialized) {
+                return `${name} AS MATERIALIZED (${cte.sql})`;
+            }
+            return `${name} AS (${cte.sql})`;
+        });
+        return `${keyword} ${parts.join(', ')}`;
+    }
+    buildMainQuery() {
+        const q = this.dialect.quoteIdent;
+        const cols = this.selectedColumns.length > 0
+            ? this.selectedColumns.map(c => q(c)).join(', ')
+            : '*';
+        let sql = `SELECT ${cols} FROM ${q(this.cteName)}`;
+        if (this.whereConditions.length > 0) {
+            sql += ` WHERE ${this.dialect.buildConditionsSQL(this.whereConditions)}`;
+        }
+        if (this.orderByClauses.length > 0) {
+            sql += ` ORDER BY ${this.orderByClauses.join(', ')}`;
+        }
+        if (this.limitCount !== undefined)
+            sql += ` LIMIT ${this.limitCount}`;
+        if (this.offsetCount !== undefined)
+            sql += ` OFFSET ${this.offsetCount}`;
+        return sql;
+    }
+}
+class NativeCTEBuilder {
+    relq;
+    dialect;
+    tableAccessorFactory;
+    cteDefinitions = [];
+    cteNames = new Set();
+    cteMetas = new Map();
+    constructor(relq, dialect, tableAccessorFactory) {
+        this.relq = relq;
+        this.dialect = dialect;
+        this.tableAccessorFactory = tableAccessorFactory;
+    }
+    with(name, callback) {
+        this.addCTE(name, callback, false);
+        return this;
+    }
+    withMaterialized(name, callback) {
+        if (!this.dialect.supportsMaterialized) {
+            throw new relq_errors_1.RelqBuilderError('MATERIALIZED CTEs are not supported on MySQL.', { builder: 'cte', hint: 'PostgreSQL 12+ only' });
+        }
+        this.addCTE(name, callback, true);
+        return this;
+    }
+    withRecursive(name, options) {
+        if (!this.dialect.supportsRecursive) {
+            throw new relq_errors_1.RelqBuilderError('Recursive CTEs are not supported on this dialect.', { builder: 'cte' });
+        }
+        this.validateName(name);
+        const tableAccessor = this.tableAccessorFactory(this.relq);
+        const baseBuilder = options.base(tableAccessor);
+        const baseSql = baseBuilder.toString();
+        const sourceTableKey = baseBuilder?._sourceTableKey;
+        const q = this.dialect.quoteIdent;
+        const selfResolve = sourceTableKey
+            ? (prop) => {
+                try {
+                    const mapped = this.relq[methods_1.INTERNAL].transformToDbColumns(sourceTableKey, { [prop]: true });
+                    const keys = Object.keys(mapped);
+                    return keys.length > 0 ? keys[0] : prop;
+                }
+                catch {
+                    return prop;
+                }
+            }
+            : (prop) => prop;
+        const selfRef = {
+            select: (...cols) => ({
+                toString: () => {
+                    const colsSql = cols.length > 0 ? cols.map(c => q(selfResolve(c))).join(', ') : '*';
+                    return `SELECT ${colsSql} FROM ${q(name)}`;
+                }
+            })
+        };
+        const recursiveSql = options.recursive(tableAccessor, selfRef).toString();
+        let columnResolver;
+        if (sourceTableKey) {
+            columnResolver = (prop) => {
+                try {
+                    const mapped = this.relq[methods_1.INTERNAL].transformToDbColumns(sourceTableKey, { [prop]: true });
+                    const keys = Object.keys(mapped);
+                    return keys.length > 0 ? keys[0] : prop;
+                }
+                catch {
+                    return prop;
+                }
+            };
+        }
+        this.cteMetas.set(name, { sourceTableKey, columnResolver });
+        this.cteDefinitions.push({ name, sql: `${baseSql} UNION ALL ${recursiveSql}`, materialized: false, recursive: true, sourceTableKey });
+        this.cteNames.add(name);
+        return this;
+    }
+    from(cteName) {
+        if (!this.cteNames.has(cteName)) {
+            throw new relq_errors_1.RelqBuilderError(`CTE "${cteName}" is not defined.`, { builder: 'cte' });
+        }
+        return new CTEFromQuery(cteName, [...this.cteDefinitions], this.dialect, this.relq);
+    }
+    validateName(name) {
+        if (this.cteNames.has(name)) {
+            throw new relq_errors_1.RelqBuilderError(`CTE "${name}" is already defined.`, { builder: 'cte' });
+        }
+    }
+    addCTE(name, callback, materialized) {
+        this.validateName(name);
+        const tableAccessor = this.tableAccessorFactory(this.relq);
+        const cteAccessor = (0, cte_accessor_1.createCTEAccessor)(this.cteNames, this.dialect, this.cteMetas);
+        const builder = callback(tableAccessor, cteAccessor);
+        const sourceTableKey = builder?._sourceTableKey;
+        const innerBuilder = builder?.builder;
+        const numericAliases = typeof innerBuilder?.getNumericAliases === 'function'
+            ? innerBuilder.getNumericAliases()
+            : undefined;
+        let columnResolver;
+        if (sourceTableKey) {
+            columnResolver = (prop) => {
+                try {
+                    const mapped = this.relq[methods_1.INTERNAL].transformToDbColumns(sourceTableKey, { [prop]: true });
+                    const keys = Object.keys(mapped);
+                    return keys.length > 0 ? keys[0] : prop;
+                }
+                catch {
+                    return prop;
+                }
+            };
+        }
+        this.cteMetas.set(name, { sourceTableKey, columnResolver });
+        this.cteDefinitions.push({ name, sql: builder.toString(), materialized, recursive: false, sourceTableKey, numericAliases });
+        this.cteNames.add(name);
+    }
+}
+exports.NativeCTEBuilder = NativeCTEBuilder;

package/dist/cjs/core/helpers/index.cjs

@@ -1,30 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.debugLog = exports.INTERNAL = exports.ReturningExecutor = exports.PaginateBuilder = exports.ConnectedRawQueryBuilder = exports.ConnectedQueryBuilder = exports.executeTransaction = exports.TransactionClient = exports.ConnectedCountBuilder = exports.ConnectedInsertBuilder = exports.ConnectedDeleteBuilder = exports.ConnectedUpdateBuilder = exports.ConnectedSelectBuilder = exports.ConnectedCTEBuilder = exports.ConnectedAggregateBuilder = void 0;
-var ConnectedAggregateBuilder_1 = require("./ConnectedAggregateBuilder.cjs");
+exports.debugLog = exports.INTERNAL = exports.ReturningExecutor = exports.PaginateBuilder = exports.ConnectedRawQueryBuilder = exports.ConnectedQueryBuilder = exports.executeTransaction = exports.TransactionClient = exports.ConnectedCountBuilder = exports.ConnectedInsertBuilder = exports.ConnectedDeleteBuilder = exports.ConnectedUpdateBuilder = exports.ConnectedSelectBuilder = exports.NativeCTEBuilder = exports.ConnectedAggregateBuilder = void 0;
+var ConnectedAggregateBuilder_1 = require("../../pg/helpers/ConnectedAggregateBuilder.cjs");
 Object.defineProperty(exports, "ConnectedAggregateBuilder", { enumerable: true, get: function () { return ConnectedAggregateBuilder_1.ConnectedAggregateBuilder; } });
-var ConnectedCTEBuilder_1 = require("./ConnectedCTEBuilder.cjs");
-Object.defineProperty(exports, "ConnectedCTEBuilder", { enumerable: true, get: function () { return ConnectedCTEBuilder_1.ConnectedCTEBuilder; } });
-var ConnectedSelectBuilder_1 = require("./ConnectedSelectBuilder.cjs");
+var native_cte_builder_1 = require("../cte/native-cte-builder.cjs");
+Object.defineProperty(exports, "NativeCTEBuilder", { enumerable: true, get: function () { return native_cte_builder_1.NativeCTEBuilder; } });
+var ConnectedSelectBuilder_1 = require("../../pg/helpers/ConnectedSelectBuilder.cjs");
 Object.defineProperty(exports, "ConnectedSelectBuilder", { enumerable: true, get: function () { return ConnectedSelectBuilder_1.ConnectedSelectBuilder; } });
-var ConnectedUpdateBuilder_1 = require("./ConnectedUpdateBuilder.cjs");
+var ConnectedUpdateBuilder_1 = require("../../pg/helpers/ConnectedUpdateBuilder.cjs");
 Object.defineProperty(exports, "ConnectedUpdateBuilder", { enumerable: true, get: function () { return ConnectedUpdateBuilder_1.ConnectedUpdateBuilder; } });
-var ConnectedDeleteBuilder_1 = require("./ConnectedDeleteBuilder.cjs");
+var ConnectedDeleteBuilder_1 = require("../../pg/helpers/ConnectedDeleteBuilder.cjs");
 Object.defineProperty(exports, "ConnectedDeleteBuilder", { enumerable: true, get: function () { return ConnectedDeleteBuilder_1.ConnectedDeleteBuilder; } });
-var ConnectedInsertBuilder_1 = require("./ConnectedInsertBuilder.cjs");
+var ConnectedInsertBuilder_1 = require("../../pg/helpers/ConnectedInsertBuilder.cjs");
 Object.defineProperty(exports, "ConnectedInsertBuilder", { enumerable: true, get: function () { return ConnectedInsertBuilder_1.ConnectedInsertBuilder; } });
-var ConnectedCountBuilder_1 = require("./ConnectedCountBuilder.cjs");
+var ConnectedCountBuilder_1 = require("../../pg/helpers/ConnectedCountBuilder.cjs");
 Object.defineProperty(exports, "ConnectedCountBuilder", { enumerable: true, get: function () { return ConnectedCountBuilder_1.ConnectedCountBuilder; } });
-var ConnectedTransactionBuilder_1 = require("./ConnectedTransactionBuilder.cjs");
+var ConnectedTransactionBuilder_1 = require("../../pg/helpers/ConnectedTransactionBuilder.cjs");
 Object.defineProperty(exports, "TransactionClient", { enumerable: true, get: function () { return ConnectedTransactionBuilder_1.TransactionClient; } });
 Object.defineProperty(exports, "executeTransaction", { enumerable: true, get: function () { return ConnectedTransactionBuilder_1.executeTransaction; } });
-var ConnectedQueryBuilder_1 = require("./ConnectedQueryBuilder.cjs");
+var ConnectedQueryBuilder_1 = require("../../pg/helpers/ConnectedQueryBuilder.cjs");
 Object.defineProperty(exports, "ConnectedQueryBuilder", { enumerable: true, get: function () { return ConnectedQueryBuilder_1.ConnectedQueryBuilder; } });
-var ConnectedRawQueryBuilder_1 = require("./ConnectedRawQueryBuilder.cjs");
+var ConnectedRawQueryBuilder_1 = require("../../pg/helpers/ConnectedRawQueryBuilder.cjs");
 Object.defineProperty(exports, "ConnectedRawQueryBuilder", { enumerable: true, get: function () { return ConnectedRawQueryBuilder_1.ConnectedRawQueryBuilder; } });
-var PaginateBuilder_1 = require("./PaginateBuilder.cjs");
+var PaginateBuilder_1 = require("../../pg/helpers/PaginateBuilder.cjs");
 Object.defineProperty(exports, "PaginateBuilder", { enumerable: true, get: function () { return PaginateBuilder_1.PaginateBuilder; } });
-var ReturningExecutor_1 = require("./ReturningExecutor.cjs");
+var ReturningExecutor_1 = require("../../pg/helpers/ReturningExecutor.cjs");
 Object.defineProperty(exports, "ReturningExecutor", { enumerable: true, get: function () { return ReturningExecutor_1.ReturningExecutor; } });
 var methods_1 = require("./methods.cjs");
 Object.defineProperty(exports, "INTERNAL", { enumerable: true, get: function () { return methods_1.INTERNAL; } });

package/dist/cjs/core/relq-base.cjs

@@ -1,47 +1,11 @@
 "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.RelqBase = void 0;
 const node_events_1 = require("node:events");
 const relq_errors_1 = require("../shared/errors/relq-errors.cjs");
-const condition_collector_1 = require("../condition/condition-collector.cjs");
 const helpers_1 = require("./helpers/index.cjs");
-const scalar_select_builder_1 = require("../select/scalar-select-builder.cjs");
 const column_mapping_1 = require("./shared/column-mapping.cjs");
 const validation_1 = require("./shared/validation.cjs");
-const table_accessor_1 = require("./shared/table-accessor.cjs");
 const cleanup_1 = require("./shared/cleanup.cjs");
 class RelqBase {
     config;
@@ -111,6 +75,7 @@ class RelqBase {
             executeCount: this._executeCount.bind(this),
             executeRun: this._executeRun.bind(this),
             executeQuery: this._executeQuery.bind(this),
+            executeRawQuery: (sql) => this._executeQuery(sql, false),
             transformToDbColumns: this._transformToDbColumns.bind(this),
             transformFromDbColumns: this._transformFromDbColumns.bind(this),
             transformResultsFromDb: this._transformResultsFromDb.bind(this),
@@ -122,7 +87,7 @@ class RelqBase {
             getTableDef: this._getTableDef.bind(this)
         };
     }
-    async _executeQuery(sql) {
+    async _executeQuery(sql, isBuilder = true) {
         if (!sql || typeof sql !== 'string' || sql.trim() === '') {
             throw new relq_errors_1.RelqConnectionError(`Invalid SQL query: ${sql === null ? 'null' : sql === undefined ? 'undefined' : 'empty string'}`);
         }
@@ -130,7 +95,7 @@ class RelqBase {
         const startTime = performance.now();
         const retryConfig = this.config.retry;
         if (!retryConfig) {
-            const result = await this._query(sql);
+            const result = await this._query(sql, isBuilder);
             return { result, duration: performance.now() - startTime };
         }
         const opts = typeof retryConfig === 'object'
@@ -139,7 +104,7 @@ class RelqBase {
         let lastError;
         for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
             try {
-                const result = await this._query(sql);
+                const result = await this._query(sql, isBuilder);
                 return { result, duration: performance.now() - startTime };
             }
             catch (error) {
@@ -200,55 +165,6 @@ class RelqBase {
             metadata: this.buildMetadata(result, duration)
         };
     }
-    get table() {
-        return (0, table_accessor_1.createTableAccessor)(this, this.schema);
-    }
-    raw(query, ...params) {
-        return new helpers_1.ConnectedRawQueryBuilder(query, params, this);
-    }
-    async transaction(callback) {
-        const { executeTransaction } = await Promise.resolve().then(() => __importStar(require("./helpers/ConnectedTransactionBuilder.cjs")));
-        return executeTransaction(this, callback);
-    }
-    with(name, query) {
-        return new helpers_1.ConnectedCTEBuilder(this).with(name, query);
-    }
-    async ctAs(tableName, query, options = {}) {
-        const queryStr = typeof query === 'string' ? query : query.toString();
-        const temp = options.temporary ? 'TEMPORARY ' : '';
-        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
-        const sql = `CREATE ${temp}TABLE ${ifNotExists}"${tableName}" AS ${queryStr}`;
-        await this[helpers_1.INTERNAL].executeQuery(sql);
-    }
-    async explain(query, options = {}) {
-        const queryStr = typeof query === 'string' ? query : query.toString();
-        const parts = ['EXPLAIN'];
-        if (options.format)
-            parts.push(`(FORMAT ${options.format.toUpperCase()}`);
-        if (options.analyze)
-            parts.push(options.format ? ', ANALYZE' : '(ANALYZE');
-        if (options.verbose)
-            parts.push(options.format || options.analyze ? ', VERBOSE' : '(VERBOSE');
-        if (options.format || options.analyze || options.verbose)
-            parts.push(')');
-        const sql = `${parts.join(' ')} ${queryStr}`;
-        const { result } = await this._executeQuery(sql);
-        if (options.format === 'json') {
-            return result.rows;
-        }
-        return result.rows.map((r) => r['QUERY PLAN'] || Object.values(r)[0]).join('\n');
-    }
-    scalar(scalars) {
-        const schema = this._getSchema();
-        return new scalar_select_builder_1.ConnectedScalarSelectBuilder(scalars, schema, {
-            executeSelectOne: this[helpers_1.INTERNAL].executeSelect.bind(this),
-            hasColumnMapping: this._hasColumnMapping.bind(this),
-            transformToDbColumns: this._transformToDbColumns.bind(this)
-        });
-    }
-    where(_tableName) {
-        return new condition_collector_1.ConditionCollector();
-    }
     on(event, listener) {
         this.emitter.on(event, listener);
         return this;