@rvoh/dream 1.4.2 → 1.5.1

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/db/migration-helpers/DreamMigrationHelpers.js

@@ -94,6 +94,42 @@ class DreamMigrationHelpers {
     ALTER TABLE ${kysely_1.sql.table(table)} DROP CONSTRAINT IF EXISTS ${kysely_1.sql.table(constraintName)};
   `.execute(db);
     }
+    /**
+     * Forces a new transaction boundary in migration execution.
+     *
+     * When called in a migration file, this method ensures that any existing transaction
+     * is committed before this migration runs, and a new transaction is started before the
+     * migration in this file. This is essential for migrations that depend on previously
+     * committed changes.
+     *
+     * Some database operations require that dependent changes be committed before they can
+     * be executed. For example, check constraints that reference enum values require those
+     * enum values to be committed to the database first.
+     *
+     * ```ts
+     * // first migration file: Add enum value
+     * export async function up(db: Kysely<any>): Promise<void> {
+     *   await DreamMigrationHelpers.addEnumValue(db, {
+     *     enumName: 'user_status',
+     *     value: 'premium'
+     *   })
+     * }
+     *
+     * // second migration file: Add check constraint that depends on the enum value
+     * export async function up(db: Kysely<any>): Promise<void> {
+     *   DreamMigrationHelpers.newTransaction() // Ensure enum value is committed first
+     *
+     *   await db.schema
+     *     .alterTable('users')
+     *     .addCheckConstraint(
+     *       'check_premium_users',
+     *       sql`status = 'premium' OR credits < 100`
+     *     )
+     *     .execute()
+     * }
+     * ```
+     */
+    static newTransaction() { }
     /**
      * Drop a value from an enum and replace it (or optionally remove it from array columns)
      *

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();
     }
     /**

package/dist/cjs/src/dream/QueryDriver/Base.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const CalendarDate_js_1 = require("../../helpers/CalendarDate.js");
+const DateTime_js_1 = require("../../helpers/DateTime.js");
 class QueryDriverBase {
     query;
     dreamClass;
@@ -24,7 +26,9 @@ class QueryDriverBase {
      * migrate the database. Must respond to the NODE_ENV value.
      */
     // eslint-disable-next-line @typescript-eslint/require-await
-    static async migrate() {
+    static async migrate(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    connectionName) {
         throw new Error('override migrate in child class');
     }
     /**
@@ -38,14 +42,18 @@ class QueryDriverBase {
      * create the database. Must respond to the NODE_ENV value.
      */
     // eslint-disable-next-line @typescript-eslint/require-await
-    static async dbCreate() {
+    static async dbCreate(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    connectionName) {
         throw new Error('override dbCreate on child class');
     }
     /**
      * delete the database. Must respond to the NODE_ENV value.
      */
     // eslint-disable-next-line @typescript-eslint/require-await
-    static async dbDrop() {
+    static async dbDrop(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    connectionName) {
         throw new Error('override dbDrop on child class');
     }
     /**
@@ -56,8 +64,14 @@ class QueryDriverBase {
      * is sorted by date in the file tree, and, more importantly, so
      * they can be run in order by your migration runner.
      */
-    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
-    static async generateMigration(migrationName, columnsWithTypes) {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async generateMigration(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    connectionName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    migrationName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    columnsWithTypes) {
         throw new Error('override generateMigration in child class');
     }
     /**
@@ -76,8 +90,10 @@ class QueryDriverBase {
      *    but this will likely need to be overridden to tailor to your custom
      *    database engine.
      */
-    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
-    static async sync(_) {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async sync(connectionName, _, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    options = {}) {
         throw new Error('override sync on child class');
     }
     /**
@@ -94,6 +110,79 @@ class QueryDriverBase {
     toKysely(type) {
         throw new Error('implement toKysely in child class (if it makes sense)');
     }
+    /**
+     * Builds a new DreamTransaction instance, provides
+     * the instance to the provided callback.
+     *
+     * ```ts
+     * await ApplicationModel.transaction(async txn => {
+     *   const user = await User.txn(txn).create({ email: 'how@yadoin' })
+     *   await Pet.txn(txn).create({ user })
+     * })
+     * ```
+     *
+     * @param callback - A callback function to call. The transaction provided to the callback can be passed to subsequent database calls within the transaction callback
+     * @returns void
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async transaction(dreamInstance, callback) {
+        throw new Error('implement transaction in child class');
+    }
+    /**
+     * @internal
+     *
+     * returns the foreign key type based on the primary key received.
+     * gives the driver the opportunity to switch i.e. bigserial to bigint.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static foreignKeyTypeFromPrimaryKey(primaryKey) {
+        throw new Error('implement foreignKeyTypeFromPrimaryKey in child class');
+    }
+    /**
+     * @internal
+     *
+     * used to return the computed primary key type based
+     * on the primaryKeyType set in the DreamApp class.
+     */
+    static primaryKeyType() {
+        throw new Error('implement primaryKeyType in child class');
+    }
+    /**
+     * @internal
+     *
+     * this method is called when dream is initializing, and is used
+     * to configure the database to utilize custom type parsers for
+     * a variety of data types.
+     *
+     * @param connectionName - the name of the connection you are doing this for
+     * @returns void
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static async setDatabaseTypeParsers(connectionName) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static async duplicateDatabase(connectionName) { }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    static async getColumnData(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    connectionName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    tableName, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    associationData) {
+        throw new Error('implement getColumnData in child class');
+    }
+    static serializeDbType(type, val) {
+        switch (type) {
+            case 'datetime':
+            case 'date':
+                if (val instanceof DateTime_js_1.DateTime || val instanceof CalendarDate_js_1.default) {
+                    return val.toSQL();
+                }
+                throw new Error(`unrecognized value found when trying to serialize for date/datetime: ${val}`);
+            default:
+                return val;
+        }
+    }
     /**
      * @internal
      *
@@ -249,6 +338,21 @@ class QueryDriverBase {
     static async saveDream(dream, txn = null) {
         throw new Error('implement saveDream in child class');
     }
+    /**
+     * destroys a dream, possibly implementing soft delete if reallyDestroy is false
+     * and the record being deleted implements soft delete.
+     *
+     * @param dream - the dream instance you wish to destroy
+     * @param txn - a transaction to encapsulate, consistently provided by underlying dream mechanisms
+     * @param reallyDestroy - whether or not to reallyDestroy. If false, soft delete will be attempted when relevant
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await, @typescript-eslint/no-unused-vars
+    static async destroyDream(dream, txn, reallyDestroy) {
+        throw new Error('implement destroyDream in child class');
+    }
+    static get syncDialect() {
+        return 'postgres';
+    }
     /**
      * Returns the sql that would be executed by this Query
      *