@relq/orm 0.1.3 → 0.1.5

package/dist/esm/pg/clients/neon-client/relq-neon.js

@@ -0,0 +1,39 @@
+import { ListenerConnection } from "../../pubsub/listener-connection.js";
+import { mergeWithPgEnv, validateEnvConfig } from "../../../utils/env-resolver.js";
+import { PgBase } from "../shared/pg-base.js";
+import { NEON_CAPABILITIES } from "./capabilities.js";
+export class RelqNeon extends PgBase {
+    dialect = 'neon';
+    capabilities = NEON_CAPABILITIES;
+    listener = null;
+    constructor(schema, config = {}) {
+        validateEnvConfig('neon', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'neon' });
+        super(schema, resolvedConfig);
+    }
+    async subscribe(channel, callback) {
+        if (!this.listener) {
+            this.listener = new ListenerConnection({
+                host: this.config.host,
+                port: this.config.port,
+                user: this.config.user,
+                password: this.config.password,
+                database: this.config.database,
+                connectionString: this.config.url,
+                ssl: this.config.ssl
+            });
+            this.listener.on('error', (err) => this.emitter.emit('listenerError', err));
+            this.listener.on('connect', () => this.emitter.emit('listenerConnect'));
+        }
+        const sub = await this.listener.subscribe(channel);
+        sub.on('notification', callback);
+        return () => sub.close();
+    }
+    async _close() {
+        if (this.listener) {
+            await this.listener.close();
+            this.listener = null;
+        }
+        await super._close();
+    }
+}

package/dist/esm/pg/clients/pg-client/relq-postgres.js

@@ -0,0 +1,52 @@
+import { ListenerConnection } from "../../pubsub/listener-connection.js";
+import { mergeWithPgEnv, validateEnvConfig } from "../../../utils/env-resolver.js";
+import { PgBase } from "../shared/pg-base.js";
+import { PG_CAPABILITIES } from "./capabilities.js";
+import { INTERNAL } from "../../../core/helpers/methods.js";
+export class RelqPostgres extends PgBase {
+    dialect = 'postgres';
+    capabilities = PG_CAPABILITIES;
+    listener = null;
+    constructor(schema, config = {}) {
+        validateEnvConfig('postgres', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'postgres' });
+        super(schema, resolvedConfig);
+    }
+    async notify(channel, payload) {
+        const escapedChannel = channel.replace(/"/g, '""');
+        if (payload === undefined) {
+            await this[INTERNAL].executeQuery(`NOTIFY "${escapedChannel}"`);
+        }
+        else {
+            const payloadStr = typeof payload === 'string' ? payload : JSON.stringify(payload);
+            const escapedPayload = payloadStr.replace(/'/g, "''");
+            await this[INTERNAL].executeQuery(`NOTIFY "${escapedChannel}", '${escapedPayload}'`);
+        }
+    }
+    async subscribe(channel, callback) {
+        if (!this.listener) {
+            this.listener = new ListenerConnection({
+                host: this.config.host,
+                port: this.config.port,
+                user: this.config.user,
+                password: this.config.password,
+                database: this.config.database,
+                connectionString: this.config.url,
+                ssl: this.config.ssl
+            });
+            this.listener.on('error', (err) => this.emitter.emit('listenerError', err));
+            this.listener.on('connect', () => this.emitter.emit('listenerConnect'));
+        }
+        const send = (payload) => this.notify(channel, payload);
+        const sub = await this.listener.subscribe(channel);
+        sub.on('notification', (data) => callback(data, send));
+        return () => sub.close();
+    }
+    async _close() {
+        if (this.listener) {
+            await this.listener.close();
+            this.listener = null;
+        }
+        await super._close();
+    }
+}

package/dist/esm/{core/pg-family → pg/clients}/shared/pg-base.js

@@ -1,10 +1,16 @@
 import { toPoolConfig, isAwsDsqlConfig } from "../../../shared/types/config-types.js";
 import { getAwsDsqlToken } from "../../../shared/aws-dsql.js";
 import { RelqConfigError, RelqConnectionError, parsePostgresError } from "../../../shared/errors/relq-errors.js";
+import { ConditionCollector } from "../../condition/condition-collector.js";
+import { NativeCTEBuilder } from "../../../core/cte/native-cte-builder.js";
+import { createPgCTEDialect } from "../../../core/cte/cte-types.js";
+import { ConnectedRawQueryBuilder } from "../../helpers/ConnectedRawQueryBuilder.js";
+import { createTableAccessor } from "../../../core/shared/table-accessor.js";
+import { ConnectedScalarSelectBuilder } from "../../select/scalar-select-builder.js";
 import { detectEnvironment } from "../../../utils/environment-detection.js";
 import { validatePoolConfig, formatPoolConfig, getSmartPoolDefaults } from "../../../utils/pool-defaults.js";
-import { debugLog } from "../../helpers/methods.js";
-import { RelqBase } from "../../relq-base.js";
+import { debugLog, INTERNAL } from "../../../core/helpers/methods.js";
+import { RelqBase } from "../../../core/relq-base.js";
 import { pgDialect } from "./pg-dialect.js";
 import { isPgConnectionError } from "./pg-error-parser.js";
 let PgPool = null;
@@ -75,7 +81,7 @@ export class PgBase extends RelqBase {
                 database: this.config.database,
                 user,
                 password: resolvedPassword,
-                connectionString: this.config.connectionString,
+                connectionString: this.config.url,
                 ssl
             });
             this.client.on('end', () => {
@@ -90,7 +96,7 @@ export class PgBase extends RelqBase {
             this.client.on('notification', (msg) => this.emitter.emit('notification', msg));
         }
     }
-    async _query(sql) {
+    async _query(sql, isBuilder = true) {
         const executeQuery = async () => {
             if (this.pool) {
                 const client = await this.pool.connect();
@@ -122,10 +128,10 @@ export class PgBase extends RelqBase {
                     return this.toDriverResult(result);
                 }
                 catch {
-                    throw parsePostgresError(error, sql);
+                    throw parsePostgresError(error, sql, isBuilder);
                 }
             }
-            throw parsePostgresError(error, sql);
+            throw parsePostgresError(error, sql, isBuilder);
         }
     }
     async _acquireClient() {
@@ -308,7 +314,7 @@ export class PgBase extends RelqBase {
             database: this.config.database,
             user,
             password: resolvedPassword,
-            connectionString: this.config.connectionString,
+            connectionString: this.config.url,
             ssl
         });
         this.client.on('end', () => {
@@ -325,6 +331,57 @@ export class PgBase extends RelqBase {
         this.clientConnected = true;
         this.emitter.emit('connect', this.client);
     }
+    get table() {
+        return createTableAccessor(this, this.schema);
+    }
+    raw(query, ...params) {
+        return new ConnectedRawQueryBuilder(query, params, this);
+    }
+    async transaction(callback, options) {
+        const { executeTransaction } = await import("../../helpers/ConnectedTransactionBuilder.js");
+        return executeTransaction(this, callback, options);
+    }
+    cte() {
+        return new NativeCTEBuilder(this, createPgCTEDialect(), (relq) => createTableAccessor(relq, this._getSchema()));
+    }
+    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) {
+        const collector = new ConditionCollector();
+        collector._tableName = tableName;
+        return collector;
+    }
 }
 const POOL_RECOVERABLE_NETWORK_CODES = new Set([
     'ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'ESERVFAIL',

package/dist/esm/{core/pg-family → pg/clients}/shared/pg-type-coercion.js

@@ -1,4 +1,4 @@
-import { deserializeValue, serializeValue, deserializeRow, deserializeRows, serializeRow, extractSchemaColumns } from "../../../utils/type-coercion.js";
+import { deserializeValue, serializeValue, deserializeRow, deserializeRows, serializeRow, extractSchemaColumns } from "../../utils/type-coercion.js";
 export const pgTypeCoercion = {
     deserializeValue,
     serializeValue

package/dist/esm/pg/clients/supabase-client/capabilities.js

@@ -0,0 +1,28 @@
+export const SUPABASE_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: true,
+    pooling: true,
+    cursors: true,
+    jsonb: true,
+    arrays: true,
+    ranges: true,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: true,
+    vacuum: true,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/esm/pg/clients/supabase-client/index.js

@@ -0,0 +1,2 @@
+export { RelqSupabase } from "./relq-supabase.js";
+export { SUPABASE_CAPABILITIES } from "./capabilities.js";

package/dist/esm/pg/clients/supabase-client/relq-supabase.js

@@ -0,0 +1,39 @@
+import { ListenerConnection } from "../../pubsub/listener-connection.js";
+import { mergeWithPgEnv, validateEnvConfig } from "../../../utils/env-resolver.js";
+import { PgBase } from "../shared/pg-base.js";
+import { SUPABASE_CAPABILITIES } from "./capabilities.js";
+export class RelqSupabase extends PgBase {
+    dialect = 'supabase';
+    capabilities = SUPABASE_CAPABILITIES;
+    listener = null;
+    constructor(schema, config = {}) {
+        validateEnvConfig('supabase', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'supabase' });
+        super(schema, resolvedConfig);
+    }
+    async subscribe(channel, callback) {
+        if (!this.listener) {
+            this.listener = new ListenerConnection({
+                host: this.config.host,
+                port: this.config.port,
+                user: this.config.user,
+                password: this.config.password,
+                database: this.config.database,
+                connectionString: this.config.url,
+                ssl: this.config.ssl
+            });
+            this.listener.on('error', (err) => this.emitter.emit('listenerError', err));
+            this.listener.on('connect', () => this.emitter.emit('listenerConnect'));
+        }
+        const sub = await this.listener.subscribe(channel);
+        sub.on('notification', callback);
+        return () => sub.close();
+    }
+    async _close() {
+        if (this.listener) {
+            await this.listener.close();
+            this.listener = null;
+        }
+        await super._close();
+    }
+}

package/dist/esm/pg/clients/timescale-client/capabilities.js

@@ -0,0 +1,28 @@
+export const TIMESCALE_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: true,
+    pooling: true,
+    cursors: true,
+    jsonb: true,
+    arrays: true,
+    ranges: true,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: true,
+    vacuum: true,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/esm/pg/clients/timescale-client/index.js

@@ -0,0 +1,2 @@
+export { RelqTimescale } from "./relq-timescale.js";
+export { TIMESCALE_CAPABILITIES } from "./capabilities.js";

package/dist/esm/pg/clients/timescale-client/relq-timescale.js

@@ -0,0 +1,39 @@
+import { ListenerConnection } from "../../pubsub/listener-connection.js";
+import { mergeWithPgEnv, validateEnvConfig } from "../../../utils/env-resolver.js";
+import { PgBase } from "../shared/pg-base.js";
+import { TIMESCALE_CAPABILITIES } from "./capabilities.js";
+export class RelqTimescale extends PgBase {
+    dialect = 'timescale';
+    capabilities = TIMESCALE_CAPABILITIES;
+    listener = null;
+    constructor(schema, config = {}) {
+        validateEnvConfig('timescale', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'timescale' });
+        super(schema, resolvedConfig);
+    }
+    async subscribe(channel, callback) {
+        if (!this.listener) {
+            this.listener = new ListenerConnection({
+                host: this.config.host,
+                port: this.config.port,
+                user: this.config.user,
+                password: this.config.password,
+                database: this.config.database,
+                connectionString: this.config.url,
+                ssl: this.config.ssl
+            });
+            this.listener.on('error', (err) => this.emitter.emit('listenerError', err));
+            this.listener.on('connect', () => this.emitter.emit('listenerConnect'));
+        }
+        const sub = await this.listener.subscribe(channel);
+        sub.on('notification', callback);
+        return () => sub.close();
+    }
+    async _close() {
+        if (this.listener) {
+            await this.listener.close();
+            this.listener = null;
+        }
+        await super._close();
+    }
+}

package/dist/esm/pg/clients/yugabytedb-client/capabilities.js

@@ -0,0 +1,28 @@
+export const YUGABYTEDB_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: false,
+    pooling: true,
+    cursors: true,
+    jsonb: true,
+    arrays: true,
+    ranges: true,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: true,
+    vacuum: true,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/esm/pg/clients/yugabytedb-client/index.js

@@ -0,0 +1,2 @@
+export { RelqYugabyteDB } from "./relq-yugabytedb.js";
+export { YUGABYTEDB_CAPABILITIES } from "./capabilities.js";

package/dist/esm/pg/clients/yugabytedb-client/relq-yugabytedb.js

@@ -0,0 +1,12 @@
+import { mergeWithPgEnv, validateEnvConfig } from "../../../utils/env-resolver.js";
+import { PgBase } from "../shared/pg-base.js";
+import { YUGABYTEDB_CAPABILITIES } from "./capabilities.js";
+export class RelqYugabyteDB extends PgBase {
+    dialect = 'yugabytedb';
+    capabilities = YUGABYTEDB_CAPABILITIES;
+    constructor(schema, config = {}) {
+        validateEnvConfig('yugabytedb', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'yugabytedb' });
+        super(schema, resolvedConfig);
+    }
+}

package/dist/esm/{condition → pg/condition}/array-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 import { ArrayStringConditionBuilder } from "./array-string-condition-builder.js";
 import { ArrayNumericConditionBuilder } from "./array-numeric-condition-builder.js";
 import { ArrayUuidConditionBuilder, ArrayDateConditionBuilder, ArrayJsonbConditionBuilder } from "./array-specialized-condition-builder.js";