@relq/orm 0.1.3 → 0.1.4

package/dist/esm/addon/pg.js

@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var __require = /* @__PURE__ */ createRequire(import.meta.url ?? "file://" + (typeof __filename !== "undefined" ? __filename : process.argv[1] || process.cwd() + "/"));
 
 // node_modules/postgres-array/index.js
 var require_postgres_array = __commonJS((exports) => {
@@ -338,9 +338,10 @@ var require_postgres_interval = __commonJS((exports, module) => {
 
 // node_modules/postgres-bytea/index.js
 var require_postgres_bytea = __commonJS((exports, module) => {
+  var bufferFrom = Buffer.from || Buffer;
   module.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;
@@ -364,7 +365,7 @@ var require_postgres_bytea = __commonJS((exports, module) => {
         }
       }
     }
-    return new Buffer(output, "binary");
+    return bufferFrom(output, "binary");
   };
 });
 

package/dist/esm/cache/query-cache.js

@@ -143,7 +143,6 @@ export class QueryCache {
         if (this.cache.size === 0)
             return;
         let keyToEvict;
-        let entryToEvict;
         switch (this.options.strategy) {
             case 'lru':
                 keyToEvict = this.cache.keys().next().value;
@@ -154,7 +153,6 @@ export class QueryCache {
                     if (entry.createdAt < oldestTime) {
                         oldestTime = entry.createdAt;
                         keyToEvict = key;
-                        entryToEvict = entry;
                     }
                 });
                 break;
@@ -164,7 +162,6 @@ export class QueryCache {
                     if (entry.size > largestSize) {
                         largestSize = entry.size;
                         keyToEvict = key;
-                        entryToEvict = entry;
                     }
                 });
                 break;
@@ -277,7 +274,7 @@ export function createQueryCacheMiddleware(options) {
         }
     };
 }
-export function withCache(cache, key, fn, ttl) {
+export function withCache(cache, key, fn, _ttl) {
     const cached = cache.get(key);
     if (cached !== undefined) {
         return cached;

package/dist/esm/core/cte/cte-accessor.js

@@ -0,0 +1,75 @@
+export 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) };
+        });
+    }
+}
+export 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/esm/core/cte/cte-types.js

@@ -0,0 +1,20 @@
+export function createPgCTEDialect() {
+    const { ConditionCollector, buildConditionsSQL } = require('../../pg/condition/condition-collector');
+    return {
+        quoteIdent: (name) => `"${name}"`,
+        supportsMaterialized: true,
+        supportsRecursive: true,
+        createCollector: () => new ConditionCollector(),
+        buildConditionsSQL: (conditions) => buildConditionsSQL(conditions),
+    };
+}
+export function createMysqlCTEDialect() {
+    const { MysqlConditionCollector, buildMysqlConditionsSQL } = require('../../mysql/condition/condition-collector');
+    return {
+        quoteIdent: (name) => `\`${name}\``,
+        supportsMaterialized: false,
+        supportsRecursive: true,
+        createCollector: () => new MysqlConditionCollector(),
+        buildConditionsSQL: (conditions) => buildMysqlConditionsSQL(conditions),
+    };
+}

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

@@ -0,0 +1,250 @@
+import { createCTEAccessor } from "./cte-accessor.js";
+import { INTERNAL } from "../helpers/methods.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+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[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[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[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;
+    }
+}
+export 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 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 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[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[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 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 RelqBuilderError(`CTE "${name}" is already defined.`, { builder: 'cte' });
+        }
+    }
+    addCTE(name, callback, materialized) {
+        this.validateName(name);
+        const tableAccessor = this.tableAccessorFactory(this.relq);
+        const cteAccessor = 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[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);
+    }
+}

package/dist/esm/core/helpers/index.js

@@ -1,13 +1,13 @@
-export { ConnectedAggregateBuilder } from "./ConnectedAggregateBuilder.js";
-export { ConnectedCTEBuilder } from "./ConnectedCTEBuilder.js";
-export { ConnectedSelectBuilder } from "./ConnectedSelectBuilder.js";
-export { ConnectedUpdateBuilder } from "./ConnectedUpdateBuilder.js";
-export { ConnectedDeleteBuilder } from "./ConnectedDeleteBuilder.js";
-export { ConnectedInsertBuilder } from "./ConnectedInsertBuilder.js";
-export { ConnectedCountBuilder } from "./ConnectedCountBuilder.js";
-export { TransactionClient, executeTransaction } from "./ConnectedTransactionBuilder.js";
-export { ConnectedQueryBuilder } from "./ConnectedQueryBuilder.js";
-export { ConnectedRawQueryBuilder } from "./ConnectedRawQueryBuilder.js";
-export { PaginateBuilder } from "./PaginateBuilder.js";
-export { ReturningExecutor } from "./ReturningExecutor.js";
+export { ConnectedAggregateBuilder } from "../../pg/helpers/ConnectedAggregateBuilder.js";
+export { NativeCTEBuilder } from "../cte/native-cte-builder.js";
+export { ConnectedSelectBuilder } from "../../pg/helpers/ConnectedSelectBuilder.js";
+export { ConnectedUpdateBuilder } from "../../pg/helpers/ConnectedUpdateBuilder.js";
+export { ConnectedDeleteBuilder } from "../../pg/helpers/ConnectedDeleteBuilder.js";
+export { ConnectedInsertBuilder } from "../../pg/helpers/ConnectedInsertBuilder.js";
+export { ConnectedCountBuilder } from "../../pg/helpers/ConnectedCountBuilder.js";
+export { TransactionClient, executeTransaction } from "../../pg/helpers/ConnectedTransactionBuilder.js";
+export { ConnectedQueryBuilder } from "../../pg/helpers/ConnectedQueryBuilder.js";
+export { ConnectedRawQueryBuilder } from "../../pg/helpers/ConnectedRawQueryBuilder.js";
+export { PaginateBuilder } from "../../pg/helpers/PaginateBuilder.js";
+export { ReturningExecutor } from "../../pg/helpers/ReturningExecutor.js";
 export { INTERNAL, debugLog } from "./methods.js";

package/dist/esm/core/relq-base.js

@@ -1,11 +1,8 @@
 import { EventEmitter } from 'node:events';
 import { RelqConnectionError } from "../shared/errors/relq-errors.js";
-import { ConditionCollector } from "../condition/condition-collector.js";
-import { ConnectedCTEBuilder, ConnectedRawQueryBuilder, INTERNAL, debugLog } from "./helpers/index.js";
-import { ConnectedScalarSelectBuilder } from "../select/scalar-select-builder.js";
+import { INTERNAL, debugLog } from "./helpers/index.js";
 import { buildColumnMappings, transformToDbColumns, transformFromDbColumns, transformResultsFromDb, hasColumnMapping } from "./shared/column-mapping.js";
 import { validateData } from "./shared/validation.js";
-import { createTableAccessor } from "./shared/table-accessor.js";
 import { registerInstance, unregisterInstance } from "./shared/cleanup.js";
 export class RelqBase {
     config;
@@ -75,6 +72,7 @@ export 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),
@@ -86,7 +84,7 @@ export class RelqBase {
             getTableDef: this._getTableDef.bind(this)
         };
     }
-    async _executeQuery(sql) {
+    async _executeQuery(sql, isBuilder = true) {
         if (!sql || typeof sql !== 'string' || sql.trim() === '') {
             throw new RelqConnectionError(`Invalid SQL query: ${sql === null ? 'null' : sql === undefined ? 'undefined' : 'empty string'}`);
         }
@@ -94,7 +92,7 @@ export 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'
@@ -103,7 +101,7 @@ export 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) {
@@ -164,55 +162,6 @@ export class RelqBase {
             metadata: this.buildMetadata(result, duration)
         };
     }
-    get table() {
-        return createTableAccessor(this, this.schema);
-    }
-    raw(query, ...params) {
-        return new ConnectedRawQueryBuilder(query, params, this);
-    }
-    async transaction(callback) {
-        const { executeTransaction } = await import("./helpers/ConnectedTransactionBuilder.js");
-        return executeTransaction(this, callback);
-    }
-    with(name, query) {
-        return new 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[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 ConnectedScalarSelectBuilder(scalars, schema, {
-            executeSelectOne: this[INTERNAL].executeSelect.bind(this),
-            hasColumnMapping: this._hasColumnMapping.bind(this),
-            transformToDbColumns: this._transformToDbColumns.bind(this)
-        });
-    }
-    where(_tableName) {
-        return new ConditionCollector();
-    }
     on(event, listener) {
         this.emitter.on(event, listener);
         return this;

package/dist/esm/core/relq-client.js

@@ -1,8 +1,19 @@
-import { RelqPostgres } from "./pg-family/pg-client/index.js";
-import { RelqNile } from "./pg-family/nile-client/index.js";
-import { RelqDsql } from "./pg-family/dsql-client/index.js";
-import { RelqCockroachDB } from "./pg-family/cockroachdb-client/index.js";
+import { RelqPostgres } from "../pg/clients/pg-client/index.js";
+import { RelqNile } from "../pg/clients/nile-client/index.js";
+import { RelqDsql } from "../pg/clients/dsql-client/index.js";
+import { RelqCockroachDB } from "../pg/clients/cockroachdb-client/index.js";
+import { RelqSupabase } from "../pg/clients/supabase-client/index.js";
+import { RelqNeon } from "../pg/clients/neon-client/index.js";
+import { RelqAlloyDB } from "../pg/clients/alloydb-client/index.js";
+import { RelqAurora } from "../pg/clients/aurora-client/index.js";
+import { RelqYugabyteDB } from "../pg/clients/yugabytedb-client/index.js";
+import { RelqCitus } from "../pg/clients/citus-client/index.js";
+import { RelqTimescale } from "../pg/clients/timescale-client/index.js";
+import { RelqMysql } from "../mysql/clients/mysql-client/index.js";
+import { RelqMariaDB } from "../mysql/clients/mariadb-client/index.js";
+import { RelqPlanetScale } from "../mysql/clients/planetscale-client/index.js";
 import { RelqConfigError } from "../shared/errors/relq-errors.js";
+const SUPPORTED_DIALECTS = 'postgres, nile, cockroachdb, awsdsql, supabase, neon, alloydb, aurora, yugabytedb, citus, timescale, mysql, mariadb, planetscale';
 class RelqImpl {
     constructor(schema, dialect, options) {
         const opts = options ?? {};
@@ -15,34 +26,43 @@ class RelqImpl {
                 return new RelqCockroachDB(schema, { ...opts, dialect: 'cockroachdb' });
             case 'awsdsql':
                 return new RelqDsql(schema, { ...opts, dialect: 'awsdsql' });
-            case 'sqlite':
-                throw new RelqConfigError(`Dialect "sqlite" is not yet implemented. ` +
-                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
-            case 'turso':
-                throw new RelqConfigError(`Dialect "turso" is not yet implemented. ` +
-                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'supabase':
+                return new RelqSupabase(schema, { ...opts, dialect: 'supabase' });
+            case 'neon':
+                return new RelqNeon(schema, { ...opts, dialect: 'neon' });
+            case 'alloydb':
+                return new RelqAlloyDB(schema, { ...opts, dialect: 'alloydb' });
+            case 'aurora':
+                return new RelqAurora(schema, { ...opts, dialect: 'aurora' });
+            case 'yugabytedb':
+                return new RelqYugabyteDB(schema, { ...opts, dialect: 'yugabytedb' });
+            case 'citus':
+                return new RelqCitus(schema, { ...opts, dialect: 'citus' });
+            case 'timescale':
+                return new RelqTimescale(schema, { ...opts, dialect: 'timescale' });
             case 'mysql':
-                throw new RelqConfigError(`Dialect "mysql" is not yet implemented. ` +
-                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+                return new RelqMysql(schema, { ...opts, dialect: 'mysql' });
             case 'mariadb':
-                throw new RelqConfigError(`Dialect "mariadb" is not yet implemented. ` +
-                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+                return new RelqMariaDB(schema, { ...opts, dialect: 'mariadb' });
             case 'planetscale':
-                throw new RelqConfigError(`Dialect "planetscale" is not yet implemented. ` +
-                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
-            case 'xata':
-                throw new RelqConfigError(`Dialect "xata" is not yet implemented. ` +
-                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+                return new RelqPlanetScale(schema, { ...opts, dialect: 'planetscale' });
             default:
                 throw new RelqConfigError(`Unknown dialect: "${dialect}". ` +
-                    `Supported dialects: postgres, nile, cockroachdb, awsdsql, sqlite, turso, mysql, mariadb, planetscale, xata`, { field: 'dialect', value: dialect });
+                    `Supported dialects: ${SUPPORTED_DIALECTS}, mysql, mariadb, planetscale`, { field: 'dialect', value: dialect });
         }
     }
 }
 export const Relq = RelqImpl;
-export { RelqPostgres } from "./pg-family/pg-client/index.js";
-export { RelqNile } from "./pg-family/nile-client/index.js";
-export { RelqDsql } from "./pg-family/dsql-client/index.js";
-export { RelqCockroachDB } from "./pg-family/cockroachdb-client/index.js";
+export { RelqPostgres } from "../pg/clients/pg-client/index.js";
+export { RelqNile } from "../pg/clients/nile-client/index.js";
+export { RelqDsql } from "../pg/clients/dsql-client/index.js";
+export { RelqCockroachDB } from "../pg/clients/cockroachdb-client/index.js";
+export { RelqSupabase } from "../pg/clients/supabase-client/index.js";
+export { RelqNeon } from "../pg/clients/neon-client/index.js";
+export { RelqAlloyDB } from "../pg/clients/alloydb-client/index.js";
+export { RelqAurora } from "../pg/clients/aurora-client/index.js";
+export { RelqYugabyteDB } from "../pg/clients/yugabytedb-client/index.js";
+export { RelqCitus } from "../pg/clients/citus-client/index.js";
+export { RelqTimescale } from "../pg/clients/timescale-client/index.js";
 export { RelqBase } from "./relq-base.js";
 export default Relq;

package/dist/esm/core/shared/column-mapping.js

@@ -1,4 +1,4 @@
-import { serializeValue, deserializeValue } from "../../utils/type-coercion.js";
+import { serializeValue, deserializeValue } from "../../pg/utils/type-coercion.js";
 export function buildColumnMappings(schema, mappings, debugLog) {
     if (!schema || typeof schema !== 'object')
         return;

package/dist/esm/core/shared/table-accessor.js

@@ -1,4 +1,4 @@
-import { ConnectedQueryBuilder } from "../helpers/ConnectedQueryBuilder.js";
+import { ConnectedQueryBuilder } from "../../pg/helpers/ConnectedQueryBuilder.js";
 export function createTableAccessor(relq, schema) {
     const tableFunction = (tableName) => {
         return new ConnectedQueryBuilder(tableName, relq);

package/dist/esm/core/shared/where.js

@@ -0,0 +1,12 @@
+import { ConditionCollector } from "../../pg/condition/condition-collector.js";
+import { MysqlConditionCollector } from "../../mysql/condition/condition-collector.js";
+export function Where(tableDefinition) {
+    if (tableDefinition.$family === 'mysql') {
+        const collector = new MysqlConditionCollector();
+        collector._tableName = tableDefinition.$name;
+        return collector;
+    }
+    const collector = new ConditionCollector();
+    collector._tableName = tableDefinition.$name;
+    return collector;
+}