@rvoh/dream 1.4.1 → 1.5.0

package/CHANGELOG.md

@@ -0,0 +1,166 @@
+## 1.5.0
+
+- add support for multiple database connections in a single dream application. To take advantage of this new feature, you can do the following:
+
+1. Add a new connection configuration to your conf/dream.ts file, providing it an explicit alternate connection name as the second argument, like so:
+
+```ts
+dreamApp.set('db', 'myAlternateConnection', {
+  primary: {
+    user: AppEnv.string('DB_USER'),
+    password: AppEnv.string('DB_PASSWORD', { optional: !AppEnv.isProduction }),
+    host: AppEnv.string('DB_HOST', { optional: true }),
+    name: AppEnv.string('DB_NAME_2', { optional: true }),
+    port: AppEnv.integer('DB_PORT_2', { optional: true }),
+    useSsl: false,
+  },
+})
+```
+
+Be sure to add any new environment variables to your .env and .env.test files.
+
+2. Run sync
+
+```sh
+yarn psy sync
+```
+
+3. add a new application model for your new connection, naming it the name of your connection, pascalized, with the string `ApplicationModel` at the end, like so:
+
+```ts
+// app/models/MyAlternateConnectionApplicationModel.ts
+
+import Dream from '../../../src/Dream.js'
+import { DBClass } from '../../types/db.alternateConnection.js'
+import { connectionTypeConfig, schema } from '../../types/dream.alternateConnection.js'
+import { globalTypeConfig } from '../../types/dream.globals.js'
+
+export default class MyAlternateConnectionApplicationModel extends Dream {
+  declare public DB: DBClass
+
+  public override get connectionName() {
+    return 'alternateConnection' as const
+  }
+
+  public override get schema(): any {
+    return schema
+  }
+
+  public override get connectionTypeConfig() {
+    return connectionTypeConfig
+  }
+
+  public override get globalTypeConfig() {
+    return globalTypeConfig
+  }
+}
+```
+
+4. Now you can proceed to generate a model for your new connection, like so:
+
+```sh
+yarn psy g:model MyNewModel someField:text --connection-name=myAlternateConnection
+```
+
+Dream will automatically read the connectionName and use it to derive the `MyAlternateConnectionApplicationModel` automatically, though if this isn't correct, you will need to manually adjust it.
+
+## 1.4.2
+
+- add ability to set custom import extension, which will be used when generating new files for your application
+
+## 1.4.1
+
+- cache Dream app earlier in the initialization sequence
+
+## 1.4.0
+
+- fix `preloadFor` infinite loop when serializers have circular references
+
+- generated STI base serializer updated to only include the single type of the particular STI child in the OpenAPI shape for that child
+
+- change `primaryKeyValue` from a getter to a method so it can return the correct type even when `primaryKey` has been overridden on a particular Dream model
+
+- remove `IdType`, an unnecessary abstraction that caused type inconsistencies
+
+- explicitly handle bigint from the database as string
+
+## 1.3.3
+
+- make `referenceTypeString` public
+
+## 1.3.2
+
+- restore aliasing in preload/load queries
+
+## 1.3.1
+
+- throw NotNullViolation when Postgres throws a not null violation
+
+- throw CheckViolation when Postgres throws a check violation
+
+## 1.3.0
+
+- sti-child generator includes check constraint instead of not-null since the column should only be not-null for that STI child (or modified by hand to accommodate more than one STI child)
+
+- add `Dream#hasAssociation`
+
+- fix preloading associations on other side of a polyorphic belongs-to association so that we don't set an association on a dream model that doesn't define that association
+
+- fix preloading association on the other side of a polymorphic belongs-to since the same association name may be defined differently on different models. For example, taskable may be a Chore or a Workout, both of which have an `images` association, but `images` goes through ChoreImage on Chore and through WorkoutImage on Workout
+
+- fix preloadFor when a rendersOne/Many renders a polymorphic belongs-to (was only preloading serializer associations for one of the polymorphically associated models)
+
+- fix preloadFor when an explicit serializer option is provided to a rendersOne/Many
+
+## 1.2.1
+
+- Throw DataTypeColumnTypeMismatch when Postgres throws an error attempting to save to a column with a value that can't be cast to the column type.
+
+## 1.2.0
+
+- Add Dream.lookup, enabling devs to tap into the IOC provided by dream to dodge circular import issues
+
+## 1.1.2
+
+- CliFileWriter does not raise error if the file we are writing is not in the file system yet.
+
+## 1.1.1
+
+- Add fs.writeFile options as third argument to CliFileWriter.write, enabling psychic to provide custom flags when writing openapi.json files.
+
+## 1.1.0
+
+- Remove support for preloadThroughColumns. They were broken, fixing them would be overly complex, and the same effect can be obtained using flatten on a serializer rendersOne
+
+## 1.0.6
+
+- Fix joining after a through a polymorphic BelongsTo
+  association.
+
+- Improve join implementation
+
+- Disable leftJoinPreload preloadThroughColumns since it doesn't actually work on through associations that resolve to a source that doesn't match the association name (and we were unnecessarily including columns in the leftJoinPreload statement even when there was no `preloadThroughColumns`, thereby bloating the queries unnecessarily)
+
+## 1.0.5
+
+- Support HasOne/Many through polymorphic BelongsTo (trick is that it uses the associated model from the HasOne/Many to limit the BelongsTo to a single associated class / table)
+
+- Fix HasOne/Many through source type
+
+- sync process is now fail-safe, leveraging a utility which caches old copies of files before writing to them. If an exception is thrown at any point during the process, dream will revert all files written using the new `CliFileWriter` class
+
+## 1.0.4
+
+- properly exclude type from `DreamParamSafeColumnNames`
+
+## 1.0.3
+
+- exclude type from `DreamParamSafeColumnNames`
+
+## 1.0.2
+
+- stop computing foreign keys in schema builder when building schema for through associations
+
+## 1.0.1
+
+- [bug] fix preloading STI model via polymporhic association (polymorphic type was being altered to the STI child rather than left as the STI base)

package/dist/cjs/src/Dream.js

@@ -2,15 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const yoctocolors_1 = require("yoctocolors");
 const errors_js_1 = require("./db/errors.js");
-const index_js_1 = require("./db/index.js");
 const associationToGetterSetterProp_js_1 = require("./decorators/field/association/associationToGetterSetterProp.js");
 const shared_js_1 = require("./decorators/field/association/shared.js");
 const shared_js_2 = require("./decorators/field/lifecycle/shared.js");
 const resortAllRecords_js_1 = require("./decorators/field/sortable/helpers/resortAllRecords.js");
-const index_js_2 = require("./dream-app/index.js");
+const index_js_1 = require("./dream-app/index.js");
 const DreamClassTransactionBuilder_js_1 = require("./dream/DreamClassTransactionBuilder.js");
 const DreamInstanceTransactionBuilder_js_1 = require("./dream/DreamInstanceTransactionBuilder.js");
-const DreamTransaction_js_1 = require("./dream/DreamTransaction.js");
 const associationQuery_js_1 = require("./dream/internal/associations/associationQuery.js");
 const associationUpdateQuery_js_1 = require("./dream/internal/associations/associationUpdateQuery.js");
 const createAssociation_js_1 = require("./dream/internal/associations/createAssociation.js");
@@ -108,8 +106,14 @@ class Dream {
     get schema() {
         throw new DreamMissingRequiredOverride_js_1.default(this.constructor, 'schema');
     }
-    get globalSchema() {
-        throw new DreamMissingRequiredOverride_js_1.default(this.constructor, 'globalSchema');
+    get connectionName() {
+        return 'default';
+    }
+    get connectionTypeConfig() {
+        throw new DreamMissingRequiredOverride_js_1.default(this.constructor, 'connectionTypeConfig');
+    }
+    get globalTypeConfig() {
+        throw new DreamMissingRequiredOverride_js_1.default(this.constructor, 'globalTypeConfig');
     }
     /**
      * Determines if the provided Dream class is the same as or a subclass of this Dream class.
@@ -842,7 +846,7 @@ class Dream {
      * @returns the found model or serializer, depending on what you are looking for
      */
     static lookup(lookupName) {
-        const dreamApp = index_js_2.default.getOrFail();
+        const dreamApp = index_js_1.default.getOrFail();
         const models = dreamApp.models;
         const serializers = dreamApp.serializers;
         return models[lookupName] || serializers[lookupName];
@@ -1733,16 +1737,8 @@ class Dream {
      * @returns void
      */
     static async transaction(callback) {
-        const dreamTransaction = new DreamTransaction_js_1.default();
-        let callbackResponse = undefined;
-        await (0, index_js_1.default)('primary')
-            .transaction()
-            .execute(async (kyselyTransaction) => {
-            dreamTransaction.kyselyTransaction = kyselyTransaction;
-            callbackResponse = (await callback(dreamTransaction));
-        });
-        await dreamTransaction.runAfterCommitHooks(dreamTransaction);
-        return callbackResponse;
+        const dbDriverClass = Query_js_1.default.dbDriverClass(this.prototype.connectionName);
+        return (await dbDriverClass.transaction(this.prototype, callback));
     }
     /**
      * Sends data through for use as passthrough data

package/dist/cjs/src/bin/index.js

@@ -1,24 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = require("../cli/index.js");
+const index_js_2 = require("../dream-app/index.js");
 const Query_js_1 = require("../dream/Query.js");
 const generateDream_js_1 = require("../helpers/cli/generateDream.js");
 const sspawn_js_1 = require("../helpers/sspawn.js");
 class DreamBin {
     static async sync(onSync, options) {
-        await Query_js_1.default.dbDriverClass().sync(onSync, options);
+        const dreamApp = index_js_2.default.getOrFail();
+        for (const connectionName of Object.keys(dreamApp.dbCredentials)) {
+            await Query_js_1.default.dbDriverClass(connectionName).sync(connectionName, onSync, options);
+        }
     }
     static async dbCreate() {
-        await Query_js_1.default.dbDriverClass().dbCreate();
+        const dreamApp = index_js_2.default.getOrFail();
+        for (const connectionName of Object.keys(dreamApp.dbCredentials)) {
+            await Query_js_1.default.dbDriverClass(connectionName).dbCreate(connectionName);
+        }
     }
     static async dbDrop() {
-        await Query_js_1.default.dbDriverClass().dbDrop();
+        const dreamApp = index_js_2.default.getOrFail();
+        for (const connectionName of Object.keys(dreamApp.dbCredentials)) {
+            await Query_js_1.default.dbDriverClass(connectionName).dbDrop(connectionName);
+        }
     }
     static async dbMigrate() {
-        await Query_js_1.default.dbDriverClass().migrate();
+        const dreamApp = index_js_2.default.getOrFail();
+        for (const connectionName of Object.keys(dreamApp.dbCredentials)) {
+            await Query_js_1.default.dbDriverClass(connectionName).migrate(connectionName);
+        }
     }
     static async dbRollback(opts) {
-        await Query_js_1.default.dbDriverClass().rollback(opts);
+        const dreamApp = index_js_2.default.getOrFail();
+        for (const connectionName of Object.keys(dreamApp.dbCredentials)) {
+            await Query_js_1.default.dbDriverClass(connectionName).rollback({ ...opts, connectionName });
+        }
     }
     static async generateDream(fullyQualifiedModelName, columnsWithTypes, options) {
         await (0, generateDream_js_1.default)({
@@ -35,8 +51,8 @@ class DreamBin {
             fullyQualifiedParentName,
         });
     }
-    static async generateMigration(migrationName, columnsWithTypes) {
-        await Query_js_1.default.dbDriverClass().generateMigration(migrationName, columnsWithTypes);
+    static async generateMigration(migrationName, columnsWithTypes, connectionName) {
+        await Query_js_1.default.dbDriverClass(connectionName).generateMigration(connectionName, migrationName, columnsWithTypes);
     }
     // though this is a private method, it is still used internally.
     // It is only made private so that people don't mistakenly try

package/dist/cjs/src/cli/index.js

@@ -15,25 +15,37 @@ ${INDENT}    subtitle:string:optional
 ${INDENT}
 ${INDENT}supported types:
 ${INDENT}    - citext:
+${INDENT}    - citext[]:
 ${INDENT}        case insensitive text (indexes and queries are automatically case insensitive)
 ${INDENT}
 ${INDENT}    - string:
+${INDENT}    - string[]:
 ${INDENT}        varchar; allowed length defaults to 255, but may be customized, e.g.: subtitle:string:128 or subtitle:string:128:optional
 ${INDENT}
 ${INDENT}    - text
+${INDENT}    - text[]
 ${INDENT}    - date
+${INDENT}    - date[]
 ${INDENT}    - datetime
+${INDENT}    - datetime[]
 ${INDENT}    - integer
+${INDENT}    - integer[]
 ${INDENT}
 ${INDENT}    - decimal:
+${INDENT}    - decimal[]:
 ${INDENT}        scale,precision is required, e.g.: volume:decimal:3,2 or volume:decimal:3,2:optional
+${INDENT}        
+${INDENT}        leveraging arrays, add the "[]" suffix, e.g.: volume:decimal[]:3,2
 ${INDENT}
 ${INDENT}    - enum:
+${INDENT}    - enum[]:
 ${INDENT}        include the enum name to automatically create the enum:
 ${INDENT}          type:enum:room_types:bathroom,kitchen,bedroom or type:enum:room_types:bathroom,kitchen,bedroom:optional
 ${INDENT}
 ${INDENT}        omit the enum values to leverage an existing enum (omits the enum type creation):
-${INDENT}          type:enum:room_types or type:enum:room_types:optional`;
+${INDENT}          type:enum:room_types or type:enum:room_types:optional
+${INDENT}
+${INDENT}        leveraging arrays, add the "[]" suffix, e.g.: type:enum[]:room_types:bathroom,kitchen,bedroom`;
 const columnsWithTypesDescription = baseColumnsWithTypesDescription +
     `
 ${INDENT}
@@ -80,10 +92,11 @@ class DreamCLI {
             .alias('g:migration')
             .description('create a new migration')
             .argument('<migrationName>', 'end with -to-table-name to prepopulate with an alterTable command')
+            .option('--connection-name <connectionName>', 'the connection name you wish to use for your migration')
             .argument('[columnsWithTypes...]', columnsWithTypesDescriptionForMigration)
-            .action(async (migrationName, columnsWithTypes) => {
+            .action(async (migrationName, columnsWithTypes, options) => {
             await initializeDreamApp();
-            await index_js_1.default.generateMigration(migrationName, columnsWithTypes);
+            await index_js_1.default.generateMigration(migrationName, columnsWithTypes, options.connectionName || 'default');
             process.exit();
         });
         program
@@ -92,6 +105,7 @@ class DreamCLI {
             .alias('generate:dream')
             .alias('g:dream')
             .option('--no-serializer')
+            .option('--connection-name <connectionName>', 'the db connection you want this attached to (defaults to the default db connection)', 'default')
             .option('--sti-base-serializer')
             .description('create a new Dream model')
             .argument('<modelName>', 'the name of the model to create, e.g. Post or Settings/CommunicationPreferences')
@@ -106,6 +120,7 @@ class DreamCLI {
             .alias('g:sti-child')
             .description('create a new Dream model that extends another Dream model, leveraging STI (single table inheritance)')
             .option('--no-serializer')
+            .option('--connection-name', 'the db connection you want this model attached to (defaults to the default connection)', 'default')
             .argument('<childModelName>', 'the name of the model to create, e.g. Post or Settings/CommunicationPreferences')
             .argument('<extends>', 'just the word "extends"')
             .argument('<parentModelName>', `fully qualified name of the parent model, e.g.:

package/dist/cjs/src/db/ConnectedToDB.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("../db/index.js");
 class ConnectedToDB {
     dreamInstance;
     dreamClass;
@@ -29,13 +28,6 @@ class ConnectedToDB {
                 return 'primary';
         }
     }
-    // ATTENTION FRED
-    // stop trying to make this async. You never learn...
-    dbFor(sqlCommandType) {
-        if (this.dreamTransaction?.kyselyTransaction)
-            return this.dreamTransaction?.kyselyTransaction;
-        return (0, index_js_1.default)(this.dbConnectionType(sqlCommandType));
-    }
     isReplicaSafe() {
         return this.innerJoinDreamClasses.reduce((accumulator, dreamClass) => accumulator && dreamClass['replicaSafe'], this.dreamClass['replicaSafe']);
     }

package/dist/cjs/src/db/DreamDbConnection.js

@@ -1,7 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dreamDbConnections = dreamDbConnections;
-exports.closeAllDbConnections = closeAllDbConnections;
 // after building for esm, importing pg using the following:
 //
 //  import * as pg from 'pg'
@@ -10,19 +7,23 @@ exports.closeAllDbConnections = closeAllDbConnections;
 // when being imported from our esm build.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
-const pg_1 = require("pg");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dreamDbConnections = dreamDbConnections;
+exports.closeAllDbConnections = closeAllDbConnections;
+exports.closeAllConnectionsForConnectionName = closeAllConnectionsForConnectionName;
 const kysely_1 = require("kysely");
 const index_js_1 = require("../dream-app/index.js");
+const protectAgainstPollutingAssignment_js_1 = require("../helpers/protectAgainstPollutingAssignment.js");
 let connections = {};
 class DreamDbConnection {
-    static getConnection(connectionType) {
+    static getConnection(connectionName, connectionType, dialectProvider) {
         const dreamApp = index_js_1.default.getOrFail();
-        const connectionName = this.getConnectionTypeName(connectionType);
-        const connection = connections[connectionName];
+        const connectionTypeName = this.getConnectionTypeName(connectionType);
+        const connection = connections[connectionName]?.[connectionTypeName];
         if (connection) {
             return connection;
         }
-        const connectionConf = dreamApp.dbConnectionConfig(connectionType);
+        const connectionConf = dreamApp.dbConnectionConfig(connectionName, connectionType);
         const dbConn = new kysely_1.Kysely({
             log(event) {
                 const dreamApp = index_js_1.default.getOrFail();
@@ -30,27 +31,14 @@ class DreamDbConnection {
                     fn(event);
                 });
             },
-            dialect: new kysely_1.PostgresDialect({
-                pool: new pg_1.default.Pool({
-                    user: connectionConf.user || '',
-                    password: connectionConf.password || '',
-                    database: dreamApp.dbName(connectionType),
-                    host: connectionConf.host || 'localhost',
-                    port: connectionConf.port || 5432,
-                    ssl: connectionConf.useSsl ? sslConfig(connectionConf) : false,
-                }),
-            }),
+            dialect: dialectProvider(connectionConf),
             plugins: [new kysely_1.CamelCasePlugin({ underscoreBetweenUppercaseLetters: true })],
         });
-        connections[this.getConnectionTypeName(connectionType)] = dbConn;
+        const protectedName = (0, protectAgainstPollutingAssignment_js_1.default)(connectionName);
+        connections[protectedName] ||= {};
+        connections[protectedName][this.getConnectionTypeName(connectionType)] = dbConn;
         return dbConn;
     }
-    static async dropAllConnections() {
-        for (const key of Object.keys(connections)) {
-            await connections[key]?.destroy();
-            delete connections[key];
-        }
-    }
     static getConnectionTypeName(connectionType) {
         return index_js_1.default.getOrFail().parallelDatabasesEnabled
             ? `${connectionType}_${process.env.VITEST_POOL_ID}`
@@ -58,20 +46,21 @@ class DreamDbConnection {
     }
 }
 exports.default = DreamDbConnection;
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function sslConfig(connectionConf) {
-    // TODO: properly configure (https://rvohealth.atlassian.net/browse/PDTC-2914)
-    return {
-        rejectUnauthorized: false,
-        // ca: fs.readFileSync('/path/to/server-certificates/root.crt').toString(),
-        // key: fs.readFileSync('/path/to/client-key/postgresql.key').toString(),
-        // cert: fs.readFileSync('/path/to/client-certificates/postgresql.crt').toString(),
-    };
-}
 function dreamDbConnections() {
     return connections;
 }
 async function closeAllDbConnections() {
-    await Promise.all(Object.values(connections).map(conn => conn.destroy()));
+    const connectionNames = Object.keys(connections);
+    for (const connectionName of connectionNames) {
+        await closeAllConnectionsForConnectionName(connectionName);
+    }
     connections = {};
 }
+async function closeAllConnectionsForConnectionName(connectionName) {
+    const protectedName = (0, protectAgainstPollutingAssignment_js_1.default)(connectionName);
+    return await Promise.allSettled(Object.keys(connections[protectedName]).map(async (key) => {
+        const conn = connections[protectedName][key];
+        await conn.destroy();
+        delete connections[protectedName][key];
+    }));
+}

package/dist/cjs/src/db/helpers/dbTypesFilenameForConnection.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dbTypesFilenameForConnection;
+function dbTypesFilenameForConnection(connectionName) {
+    return connectionName === 'default' ? 'db.ts' : `db.${connectionName}.ts`;
+}

package/dist/cjs/src/{bin/helpers/sync.js → db/helpers/syncDbTypesFiles.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = writeSyncFile;
+exports.default = syncDbTypesFiles;
 const fs = require("node:fs/promises");
 const path = require("node:path");
 const CliFileWriter_js_1 = require("../../cli/CliFileWriter.js");
@@ -13,13 +13,16 @@ const EnvInternal_js_1 = require("../../helpers/EnvInternal.js");
 const dreamPath_js_1 = require("../../helpers/path/dreamPath.js");
 const snakeify_js_1 = require("../../helpers/snakeify.js");
 const sspawn_js_1 = require("../../helpers/sspawn.js");
-async function writeSyncFile() {
+const dbTypesFilenameForConnection_js_1 = require("./dbTypesFilenameForConnection.js");
+async function syncDbTypesFiles(connectionName) {
     const dreamApp = index_js_2.default.getOrFail();
-    const dbConf = dreamApp.dbConnectionConfig('primary');
-    const dbSyncFilePath = path.join((0, dreamPath_js_1.default)('types'), 'db.ts');
+    const dbConf = dreamApp.dbConnectionConfig(connectionName, 'primary');
+    const driverClass = dreamApp.dbConnectionQueryDriverClass(connectionName);
+    const dbFilename = (0, dbTypesFilenameForConnection_js_1.default)(connectionName);
+    const dbSyncFilePath = path.join((0, dreamPath_js_1.default)('types'), dbFilename);
     const absoluteDbSyncPath = path.join(dreamApp.projectRoot, dbSyncFilePath);
     await CliFileWriter_js_1.CliFileWriter.cache(absoluteDbSyncPath);
-    await (0, sspawn_js_1.default)(`kysely-codegen --dialect=postgres --url=postgres://${dbConf.user}:${dbConf.password}@${dbConf.host}:${dbConf.port}/${dbConf.name} --out-file=${absoluteDbSyncPath}`, {
+    await (0, sspawn_js_1.default)(`kysely-codegen --dialect=${driverClass.syncDialect} --url=${driverClass.syncDialect}://${dbConf.user}:${dbConf.password}@${dbConf.host}:${dbConf.port}/${dbConf.name} --out-file=${absoluteDbSyncPath}`, {
         onStdout: message => {
             index_js_1.default.logger.logContinueProgress((0, colorize_js_1.default)(`[db]`, { color: 'cyan' }) + ' ' + message, {
                 logPrefixColor: 'cyan',

package/dist/cjs/src/db/index.js

@@ -4,8 +4,9 @@ exports.default = db;
 const DateTime_js_1 = require("../helpers/DateTime.js");
 const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
 const DreamDbConnection_js_1 = require("./DreamDbConnection.js");
+const Postgres_js_1 = require("../dream/QueryDriver/Postgres.js");
 if (EnvInternal_js_1.default.string('TZ', { optional: true }))
     DateTime_js_1.Settings.defaultZone = EnvInternal_js_1.default.string('TZ');
-function db(connectionType = 'primary') {
-    return DreamDbConnection_js_1.default.getConnection(connectionType);
+function db(connectionName = 'default', connectionType = 'primary', dialectProvider = Postgres_js_1.default.dialectProvider(connectionName, connectionType)) {
+    return DreamDbConnection_js_1.default.getConnection(connectionName, connectionType, dialectProvider);
 }

package/dist/cjs/src/decorators/field/sortable/helpers/setPosition.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = setPosition;
 exports.applySortableScopesToQuery = applySortableScopesToQuery;
-const index_js_1 = require("../../../../db/index.js");
+exports.getPostgresQueryDriver = getPostgresQueryDriver;
+const index_js_1 = require("../../../../dream-app/index.js");
+const Postgres_js_1 = require("../../../../dream/QueryDriver/Postgres.js");
 const range_js_1 = require("../../../../helpers/range.js");
 const getColumnForSortableScope_js_1 = require("./getColumnForSortableScope.js");
 const scopeArray_js_1 = require("./scopeArray.js");
@@ -79,7 +81,10 @@ async function applyUpdates({ position, previousPosition, dream, positionField,
 }
 async function setNewPosition({ dream, positionField, query, scope, previousPosition, txn, }) {
     const newPosition = (await (0, sortableQueryExcludingDream_js_1.default)(dream, query, scope).max(positionField)) + 1;
-    const dbOrTxn = txn ? txn.kyselyTransaction : (0, index_js_1.default)('primary');
+    const queryDriverClass = getPostgresQueryDriver(dream.connectionName || 'default');
+    const dbOrTxn = txn
+        ? txn.kyselyTransaction
+        : queryDriverClass.dbFor(dream.connectionName || 'default', 'primary');
     await dbOrTxn
         .updateTable(dream.table)
         .where(dream['_primaryKey'], '=', dream.primaryKeyValue())
@@ -156,3 +161,13 @@ async function updatePositionForRecord(txn, dream, positionField, position) {
     })
         .execute();
 }
+function getPostgresQueryDriver(connectionName) {
+    const queryDriverClass = index_js_1.default.getOrFail().dbConnectionQueryDriverClass(connectionName);
+    if (!(queryDriverClass === Postgres_js_1.default)) {
+        throw new Error(`
+      ${queryDriverClass.name} is not an instance of PostgresQueryDriver.
+      You must be using the PostgresQueryDriver when leveraging the Sortable decorator
+      `);
+    }
+    return queryDriverClass;
+}

package/dist/cjs/src/dream/Query.js

@@ -20,7 +20,6 @@ const index_js_2 = require("../ops/index.js");
 const computedPaginatePage_js_1 = require("./internal/computedPaginatePage.js");
 const convertDreamClassAndAssociationNameTupleArrayToPreloadArgs_js_1 = require("./internal/convertDreamClassAndAssociationNameTupleArrayToPreloadArgs.js");
 const extractNestedPaths_js_1 = require("./internal/extractNestedPaths.js");
-const Postgres_js_1 = require("./QueryDriver/Postgres.js");
 class Query {
     /**
      * @internal
@@ -1170,13 +1169,17 @@ class Query {
     async all(options = {}) {
         return await this.dbDriverInstance().takeAll(options);
     }
-    static dbDriverClass() {
-        return Postgres_js_1.default;
+    static dbDriverClass(connectionName) {
+        const dreamApp = index_js_1.default.getOrFail();
+        return dreamApp.dbConnectionQueryDriverClass(connectionName);
     }
     dbDriverInstance(query = this) {
-        const driverClass = Query.dbDriverClass();
+        const driverClass = Query.dbDriverClass(this.connectionName);
         return new driverClass(query);
     }
+    get connectionName() {
+        return this.dreamInstance.connectionName || 'default';
+    }
     /**
      * Paginates the results of your query, accepting a pageSize and page argument,
      * which it uses to segment your query into pages, leveraging limit and offset
@@ -1281,7 +1284,7 @@ class Query {
         const query = this.orderStatements.length
             ? this
             : this.order({ [this.namespacedPrimaryKey]: 'asc' });
-        const dbDriverClass = Query.dbDriverClass();
+        const dbDriverClass = Query.dbDriverClass(this.connectionName);
         return await new dbDriverClass(query).takeOne();
     }
     /**
@@ -1321,7 +1324,7 @@ class Query {
         const query = this.orderStatements.length
             ? this.invertOrder()
             : this.order({ [this.namespacedPrimaryKey]: 'desc' });
-        const dbDriverClass = Query.dbDriverClass();
+        const dbDriverClass = Query.dbDriverClass(this.connectionName);
         return await new dbDriverClass(query).takeOne();
     }
     /**