@rvoh/dream 1.4.1 → 1.5.0

package/dist/esm/src/{helpers/db → dream/QueryDriver/helpers/kysely}/runMigration.js

@@ -1,15 +1,19 @@
 import { FileMigrationProvider, Migrator } from 'kysely';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import DreamCLI from '../../cli/index.js';
-import colorize from '../../cli/logger/loggable/colorize.js';
-import DreamDbConnection from '../../db/DreamDbConnection.js';
-import db from '../../db/index.js';
-import DreamApp from '../../dream-app/index.js';
-export default async function runMigration({ mode = 'migrate' } = {}) {
+import colorize from '../../../../cli/logger/loggable/colorize.js';
+import { closeAllConnectionsForConnectionName, closeAllDbConnections, } from '../../../../db/DreamDbConnection.js';
+import db from '../../../../db/index.js';
+import DreamApp from '../../../../dream-app/index.js';
+import DreamCLI from '../../../../cli/index.js';
+export default async function runMigration({ connectionName, mode = 'migrate', dialectProvider, }) {
     const dreamApp = DreamApp.getOrFail();
-    const migrationFolder = path.join(dreamApp.projectRoot, dreamApp.paths.db, 'migrations');
-    const kyselyDb = db('primary');
+    const migrationFolder = connectionName === 'default'
+        ? path.join(dreamApp.projectRoot, dreamApp.paths.db, 'migrations')
+        : path.join(dreamApp.projectRoot, dreamApp.paths.db, 'migrations', connectionName);
+    // Ensure the migration folder exists
+    await fs.mkdir(migrationFolder, { recursive: true });
+    const kyselyDb = db(connectionName, 'primary', dialectProvider);
     const migrator = new Migrator({
         db: kyselyDb,
         allowUnorderedMigrations: true,
@@ -25,7 +29,7 @@ export default async function runMigration({ mode = 'migrate' } = {}) {
     else if (mode === 'rollback') {
         await rollback(migrator);
     }
-    await DreamDbConnection.dropAllConnections();
+    await closeAllConnectionsForConnectionName(connectionName);
 }
 async function migrate(migrator) {
     let nextMigrationRequiringNewTransaction = await findNextMigrationRequiringNewTransaction(migrator);
@@ -71,7 +75,7 @@ async function rollback(migrator) {
         await handleError(error, 'rollback');
 }
 async function handleError(error, mode) {
-    await DreamDbConnection.dropAllConnections();
+    await closeAllDbConnections();
     DreamApp.logWithLevel('error', `failed to ${migratedActionCurrentTense(mode)}`);
     DreamApp.logWithLevel('error', error);
     process.exit(1);

package/dist/esm/src/{helpers/db → dream/QueryDriver/helpers/pg}/createDb.js

@@ -1,17 +1,17 @@
-import DreamApp from '../../dream-app/index.js';
-import EnvInternal from '../EnvInternal.js';
+import DreamApp from '../../../../dream-app/index.js';
+import EnvInternal from '../../../../helpers/EnvInternal.js';
 import loadPgClient from './loadPgClient.js';
-export default async function createDb(connection, dbName) {
+export default async function createDb(connectionName, connectionType, dbName) {
     // this was only ever written to clear the db between tests or in development,
     // so there is no way to drop in production
     if (EnvInternal.isProduction)
         return false;
     const dreamApp = DreamApp.getOrFail();
-    const dbConf = dreamApp.dbConnectionConfig(connection);
+    const dbConf = dreamApp.dbConnectionConfig(connectionName, connectionType);
     dbName ||= dbConf.name || null;
     if (!dbName)
         throw new Error('Must either pass a dbName to the create function, or else ensure that DB_NAME is set in the env');
-    const client = await loadPgClient({ useSystemDb: true });
+    const client = await loadPgClient({ useSystemDb: true, connectionName });
     await client.query(`CREATE DATABASE ${dbName};`);
     await client.end();
 }

package/dist/esm/src/{helpers/db → dream/QueryDriver/helpers/pg}/dropDb.js

@@ -1,18 +1,18 @@
-import DreamCLI from '../../cli/index.js';
-import DreamApp from '../../dream-app/index.js';
-import EnvInternal from '../EnvInternal.js';
+import DreamCLI from '../../../../cli/index.js';
+import DreamApp from '../../../../dream-app/index.js';
+import EnvInternal from '../../../../helpers/EnvInternal.js';
 import loadPgClient from './loadPgClient.js';
-export default async function dropDb(connection, dbName) {
+export default async function dropDb(connectionName, connection, dbName) {
     // this was only ever written to clear the db between tests or in development,
     // so there is no way to drop in production
     if (EnvInternal.isProduction)
         return false;
     const dreamApp = DreamApp.getOrFail();
-    const dbConf = dreamApp.dbConnectionConfig(connection);
+    const dbConf = dreamApp.dbConnectionConfig(connectionName, connection);
     dbName ||= dbConf.name || null;
     if (!dbName)
         throw new Error('Must either pass a dbName to the drop function, or else ensure that DB_NAME is set in the env');
-    const client = await loadPgClient({ useSystemDb: true });
+    const client = await loadPgClient({ useSystemDb: true, connectionName });
     await maybeDropDuplicateDatabases(client, dbName);
     await client.query(`DROP DATABASE IF EXISTS ${dbName};`);
 }

package/dist/esm/src/{helpers/db → dream/QueryDriver/helpers/pg}/loadPgClient.js

@@ -7,10 +7,12 @@
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import pg from 'pg';
-import DreamApp from '../../dream-app/index.js';
-export default async function loadPgClient({ useSystemDb } = {}) {
+import DreamApp from '../../../../dream-app/index.js';
+export default async function loadPgClient({ connectionName, useSystemDb, }) {
     const dreamconf = DreamApp.getOrFail();
-    const creds = dreamconf.dbCredentials.primary;
+    const creds = dreamconf.dbCredentialsFor(connectionName)?.primary;
+    if (!creds)
+        throw new Error(`failed to load db credentials for connection: ${connectionName}`);
     const client = new pg.Client({
         host: creds.host || 'localhost',
         port: creds.port,

package/dist/esm/src/dream/internal/destroyDream.js

@@ -1,6 +1,6 @@
+import DreamApp from '../../dream-app/index.js';
 import destroyAssociatedRecords from './destroyAssociatedRecords.js';
 import runHooksFor from './runHooksFor.js';
-import softDeleteDream from './softDeleteDream.js';
 /**
  * @internal
  *
@@ -56,13 +56,6 @@ function shouldSoftDelete(dream, reallyDestroy) {
  * deleting by one of the beforeDestroy model hooks
  */
 async function maybeDestroyDream(dream, txn, reallyDestroy) {
-    if (shouldSoftDelete(dream, reallyDestroy)) {
-        await softDeleteDream(dream, txn);
-    }
-    else if (!dream['_preventDeletion']) {
-        await txn.kyselyTransaction
-            .deleteFrom(dream.table)
-            .where(dream['_primaryKey'], '=', dream.primaryKeyValue())
-            .execute();
-    }
+    const dbDriverClass = DreamApp.getOrFail().dbConnectionQueryDriverClass(dream.connectionName);
+    await dbDriverClass.destroyDream(dream, txn, reallyDestroy);
 }

package/dist/esm/src/dream/internal/saveDream.js

@@ -28,7 +28,7 @@ export default async function saveDream(dream, txn = null, { skipHooks = false }
     // BeforeSave/Update actions may clear all the data that we intended to save, leaving us with
     // an invalid update command. The Sortable decorator is an example of this.
     if (!alreadyPersisted || hasUnsavedData) {
-        const data = await Query.dbDriverClass().saveDream(dream, txn);
+        const data = await Query.dbDriverClass(dream.connectionName || 'default').saveDream(dream, txn);
         dream['isPersisted'] = true;
         dream.setAttributes(data);
     }

package/dist/esm/src/dream/internal/similarity/SimilarityBuilder.js

@@ -8,6 +8,7 @@ import namespaceColumn from '../../../helpers/namespaceColumn.js';
 import { TRIGRAM_OPERATORS } from '../../constants.js';
 import similaritySelectSql from './similaritySelectSql.js';
 import similarityWhereSql from './similarityWhereSql.js';
+import { getPostgresQueryDriver } from '../../../decorators/field/sortable/helpers/setPosition.js';
 export default class SimilarityBuilder extends ConnectedToDB {
     whereStatement;
     whereNotStatement;
@@ -214,8 +215,9 @@ export default class SimilarityBuilder extends ConnectedToDB {
         const schema = this.dreamClass.prototype.schema;
         const primaryKeyName = this.dreamClass.primaryKey;
         const { tableName, tableAlias, columnName } = similarityStatement;
+        const queryDriverClass = getPostgresQueryDriver(this.dreamInstance.connectionName);
         // eslint-disable-next-line @typescript-eslint/unbound-method
-        const { ref } = this.dbFor('select').dynamic;
+        const { ref } = queryDriverClass.dbFor(this.dreamInstance.connectionName, this.dbConnectionType('select')).dynamic;
         const validatedTableAlias = validateTableAlias(tableAlias);
         const validatedPrimaryKey = validateColumn(schema, tableName, primaryKeyName);
         const nestedQuery = this.buildNestedSelectQuery({
@@ -245,7 +247,9 @@ export default class SimilarityBuilder extends ConnectedToDB {
             statementType,
         });
         const trigramSearchAlias = this.similaritySearchId(tableAlias, columnName);
-        const selectQuery = this.dbFor('select')
+        const queryDriverClass = getPostgresQueryDriver(this.dreamInstance.connectionName);
+        const selectQuery = queryDriverClass
+            .dbFor(this.dreamInstance.connectionName, this.dbConnectionType('select'))
             .selectFrom(validatedTableAlias)
             .select(`${trigramSearchAlias}.trigram_search_id`)
             .innerJoin(nestedQuery.as(trigramSearchAlias), join => join.onRef(namespaceColumn(validatedPrimaryKey, validatedTableAlias), '=', namespaceColumn('trigram_search_id', trigramSearchAlias)));
@@ -257,7 +261,9 @@ export default class SimilarityBuilder extends ConnectedToDB {
         const { columnName, opsStatement, tableName } = similarityStatement;
         const validatedTable = validateTable(schema, tableName);
         const validatedPrimaryKey = validateColumn(schema, tableName, primaryKeyName);
-        let nestedQuery = this.dbFor('select')
+        const queryDriverClass = getPostgresQueryDriver(this.dreamInstance.connectionName);
+        let nestedQuery = queryDriverClass
+            .dbFor(this.dreamInstance.connectionName, this.dbConnectionType('select'))
             .selectFrom(tableName)
             .select(eb => {
             const tableNameRef = eb.ref(validatedTable);

package/dist/esm/src/dream-app/index.js

@@ -1,26 +1,16 @@
-// after building for esm, importing pg using the following:
-//
-//  import * as pg from 'pg'
-//
-// will crash. This is difficult to discover, since it only happens
-// when being imported from our esm build.
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import pg from 'pg';
 import * as util from 'node:util';
-import db from '../db/index.js';
 import validateTable from '../db/validators/validateTable.js';
+import Query from '../dream/Query.js';
 import Encrypt from '../encrypt/index.js';
 import DreamAppInitMissingCallToLoadModels from '../errors/dream-app/DreamAppInitMissingCallToLoadModels.js';
 import DreamAppInitMissingMissingProjectRoot from '../errors/dream-app/DreamAppInitMissingMissingProjectRoot.js';
 import CalendarDate from '../helpers/CalendarDate.js';
-import { findCitextArrayOid, findCorrespondingArrayOid, findEnumArrayOids, parsePostgresBigint, parsePostgresDate, parsePostgresDatetime, parsePostgresDecimal, } from '../helpers/customPgParsers.js';
 import { DateTime, Settings } from '../helpers/DateTime.js';
 import EnvInternal from '../helpers/EnvInternal.js';
 import { cacheDreamApp, getCachedDreamAppOrFail } from './cache.js';
 import importModels, { getModelsOrFail } from './helpers/importers/importModels.js';
 import importSerializers, { getSerializersOrFail, setCachedSerializers, } from './helpers/importers/importSerializers.js';
-const pgTypes = pg.types;
+import PostgresQueryDriver from '../dream/QueryDriver/Postgres.js';
 // this needs to be done top-level to ensure proper configuration
 Settings.defaultZone = 'UTC';
 export default class DreamApp {
@@ -44,7 +34,7 @@ export default class DreamApp {
             setCachedSerializers({});
         cacheDreamApp(dreamApp);
         if (!EnvInternal.boolean('BYPASS_DB_CONNECTIONS_DURING_INIT'))
-            await this.setDatabaseTypeParsers();
+            await this.setDatabaseTypeParsers(dreamApp);
         await deferCb?.(dreamApp);
         for (const plugin of dreamApp.plugins) {
             await plugin(dreamApp);
@@ -87,43 +77,10 @@ export default class DreamApp {
      *
      *
      */
-    static async setDatabaseTypeParsers() {
-        const kyselyDb = db('primary');
-        pgTypes.setTypeParser(pgTypes.builtins.DATE, parsePostgresDate);
-        pgTypes.setTypeParser(pgTypes.builtins.TIMESTAMP, parsePostgresDatetime);
-        pgTypes.setTypeParser(pgTypes.builtins.TIMESTAMPTZ, parsePostgresDatetime);
-        pgTypes.setTypeParser(pgTypes.builtins.NUMERIC, parsePostgresDecimal);
-        pgTypes.setTypeParser(pgTypes.builtins.INT8, parsePostgresBigint);
-        const textArrayOid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.TEXT);
-        if (textArrayOid) {
-            let oid;
-            const textArrayParser = pgTypes.getTypeParser(textArrayOid);
-            function transformPostgresArray(transformer) {
-                return (value) => textArrayParser(value).map(str => transformer(str));
-            }
-            const enumArrayOids = await findEnumArrayOids(kyselyDb);
-            enumArrayOids.forEach((enumArrayOid) => pgTypes.setTypeParser(enumArrayOid, textArrayParser));
-            oid = await findCitextArrayOid(kyselyDb);
-            if (oid)
-                pgTypes.setTypeParser(oid, textArrayParser);
-            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.UUID);
-            if (oid)
-                pgTypes.setTypeParser(oid, textArrayParser);
-            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.DATE);
-            if (oid)
-                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDate));
-            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.TIMESTAMP);
-            if (oid)
-                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDatetime));
-            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.TIMESTAMPTZ);
-            if (oid)
-                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDatetime));
-            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.NUMERIC);
-            if (oid)
-                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresDecimal));
-            oid = await findCorrespondingArrayOid(kyselyDb, pgTypes.builtins.INT8);
-            if (oid)
-                pgTypes.setTypeParser(oid, transformPostgresArray(parsePostgresBigint));
+    static async setDatabaseTypeParsers(dreamApp) {
+        for (const connectionName of Object.keys(dreamApp._dbCredentials)) {
+            const dbDriverClass = Query.dbDriverClass(connectionName);
+            await dbDriverClass.setDatabaseTypeParsers(connectionName);
         }
     }
     static checkKey(encryptionIdentifier, key, algorithm) {
@@ -165,10 +122,15 @@ Try setting it to something valid, like:
     get specialHooks() {
         return this._specialHooks;
     }
-    _dbCredentials;
+    _dbCredentials = {};
     get dbCredentials() {
         return this._dbCredentials;
     }
+    dbCredentialsFor(connectionName) {
+        if (this._dbCredentials[connectionName])
+            return this._dbCredentials[connectionName];
+        return null;
+    }
     _encryption;
     get encryption() {
         return this._encryption;
@@ -217,10 +179,14 @@ Try setting it to something valid, like:
     get packageManager() {
         return this._packageManager;
     }
+    _importExtension = '.js';
+    get importExtension() {
+        return this._importExtension;
+    }
     loadedModels = false;
     constructor(opts) {
         if (opts?.db)
-            this._dbCredentials = opts.db;
+            this._dbCredentials['default'] = opts.db;
         if (opts?.primaryKeyType)
             this._primaryKeyType = opts.primaryKeyType;
         if (opts?.projectRoot)
@@ -247,22 +213,38 @@ Try setting it to something valid, like:
     get serializers() {
         return getSerializersOrFail();
     }
-    dbName(connection) {
-        const conf = this.dbConnectionConfig(connection);
+    dbName(connectionName, connection) {
+        const conf = this.dbConnectionConfig(connectionName, connection);
         return this.parallelDatabasesEnabled ? `${conf.name}_${process.env.VITEST_POOL_ID}` : conf.name;
     }
-    dbConnectionConfig(connection) {
-        const conf = this.dbCredentials?.[connection] || this.dbCredentials?.primary;
-        if (!conf)
+    dbConnectionConfig(connectionName, connection) {
+        const conf = this.dbCredentialsFor(connectionName)?.[connection] || this.dbCredentialsFor(connectionName)?.primary;
+        if (!conf) {
             throw new Error(`
       Cannot find a connection config given the following connection and node environment:
+        connectionName: ${connectionName}
         connection: ${connection}
         NODE_ENV: ${EnvInternal.nodeEnv}
     `);
+        }
         return conf;
     }
-    get hasReplicaConfig() {
-        return !!this.dbCredentials.replica;
+    dbConnectionQueryDriverClass(connectionName) {
+        const conf = this.dbCredentialsFor(connectionName);
+        if (!conf) {
+            throw new Error(`
+      Cannot find a db credentials for the given connectionName:
+        connectionName: ${connectionName}
+        NODE_ENV: ${EnvInternal.nodeEnv}
+    `);
+        }
+        return (conf.queryDriverClass) || (PostgresQueryDriver);
+    }
+    dbConnectionKeys() {
+        return Object.keys(this.dbCredentials);
+    }
+    hasReplicaConfig(connectionName) {
+        return !!this.dbCredentials[connectionName]?.replica;
     }
     get parallelDatabasesEnabled() {
         return (!!this.parallelTests &&
@@ -283,10 +265,15 @@ Try setting it to something valid, like:
     plugin(cb) {
         this._plugins.push(cb);
     }
-    set(applyOption, options) {
+    set(applyOption, options, secondaryOptions) {
         switch (applyOption) {
             case 'db':
-                this._dbCredentials = options;
+                if (typeof options === 'string') {
+                    this._dbCredentials[options] = secondaryOptions;
+                }
+                else {
+                    this._dbCredentials['default'] = options;
+                }
                 break;
             case 'encryption':
                 this._encryption = options;
@@ -294,6 +281,9 @@ Try setting it to something valid, like:
             case 'primaryKeyType':
                 this._primaryKeyType = options;
                 break;
+            case 'importExtension':
+                this._importExtension = options;
+                break;
             case 'logger':
                 this._logger = options;
                 break;
@@ -356,3 +346,7 @@ function argToString(arg) {
     return util.inspect(arg, { depth: 3 });
 }
 export const DreamAppAllowedPackageManagersEnumValues = ['yarn', 'npm', 'pnpm'];
+// GeneratorImportStyles are used by CLI generators to determine how
+// to style import suffixes. When integrating with other apps, this
+// suffix style can change, and may need to be configured.
+export const GeneratorImportStyles = ['.js', '.ts', 'none'];

package/dist/esm/src/helpers/cli/SchemaBuilder.js

@@ -1,11 +1,10 @@
-import { sql } from 'kysely';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { CliFileWriter } from '../../cli/CliFileWriter.js';
-import { isPrimitiveDataType } from '../../db/dataTypes.js';
-import _db from '../../db/index.js';
+import dbTypesFilenameForConnection from '../../db/helpers/dbTypesFilenameForConnection.js';
 import DreamApp from '../../dream-app/index.js';
 import { DreamConst } from '../../dream/constants.js';
+import Query from '../../dream/Query.js';
 import FailedToIdentifyAssociation from '../../errors/schema-builder/FailedToIdentifyAssociation.js';
 import camelize from '../camelize.js';
 import compact from '../compact.js';
@@ -16,7 +15,11 @@ import sortBy from '../sortBy.js';
 import uniq from '../uniq.js';
 import autogeneratedFileDisclaimer from './autoGeneratedFileDisclaimer.js';
 export default class SchemaBuilder {
+    connectionName;
     hasForeignKeyError = false;
+    constructor(connectionName) {
+        this.connectionName = connectionName;
+    }
     async build() {
         const { schemaConstContent, passthroughColumns, allDefaultScopeNames } = await this.buildSchemaContent();
         const imports = await this.getSchemaImports(schemaConstContent);
@@ -37,19 +40,27 @@ ${importStr}
 
 ${schemaConstContent}
 
-export const globalSchema = {
+export const connectionTypeConfig = {
   passthroughColumns: ${stringifyArray(uniq(passthroughColumns.sort()), { indent: 4 })},
   allDefaultScopeNames: ${stringifyArray(uniq(allDefaultScopeNames.sort()), { indent: 4 })},
   globalNames: {
     models: ${this.globalModelNames()},
-    serializers: ${stringifyArray(Object.keys(dreamApp.serializers || {}).sort(), { indent: 6 })},
   },
 } as const
 `;
-        // const newSchemaFileContents = `\
-        // ${schemaConstContent}
-        // `
-        const schemaPath = path.join(dreamApp.projectRoot, dreamApp.paths.types, 'dream.ts');
+        const schemaPath = this.connectionName === 'default'
+            ? path.join(dreamApp.projectRoot, dreamApp.paths.types, 'dream.ts')
+            : path.join(dreamApp.projectRoot, dreamApp.paths.types, `dream.${camelize(this.connectionName)}.ts`);
+        await CliFileWriter.write(schemaPath, newSchemaFileContents);
+    }
+    static async buildGlobalTypes() {
+        const dreamApp = DreamApp.getOrFail();
+        const newSchemaFileContents = `\
+export const globalTypeConfig = {
+  serializers: ${stringifyArray(Object.keys(dreamApp.serializers || {}).sort(), { indent: 6 })},
+} as const
+`;
+        const schemaPath = path.join(dreamApp.projectRoot, dreamApp.paths.types, 'dream.globals.ts');
         await CliFileWriter.write(schemaPath, newSchemaFileContents);
     }
     globalModelNames() {
@@ -57,6 +68,7 @@ export const globalSchema = {
         const models = dreamApp.models;
         return `{
       ${Object.keys(models)
+            .filter(key => models[key]?.prototype?.connectionName === this.connectionName)
             .map(key => `'${key}': '${models[key]?.prototype?.table}'`)
             .join(',\n      ')}
     }`;
@@ -200,32 +212,8 @@ may need to update the table getter in the corresponding Dream.
         };
     }
     async getColumnData(tableName, associationData) {
-        const db = _db('primary');
-        const sqlQuery = sql `SELECT column_name, udt_name::regtype, is_nullable, data_type FROM information_schema.columns WHERE table_name = ${tableName}`;
-        const columnToDBTypeMap = await sqlQuery.execute(db);
-        const rows = columnToDBTypeMap.rows;
-        const columnData = {};
-        rows.forEach(row => {
-            const isEnum = ['USER-DEFINED', 'ARRAY'].includes(row.dataType) && !isPrimitiveDataType(row.udtName);
-            const isArray = ['ARRAY'].includes(row.dataType);
-            const associationMetadata = associationData[row.columnName];
-            columnData[camelize(row.columnName)] = {
-                dbType: row.udtName,
-                allowNull: row.isNullable === 'YES',
-                enumType: isEnum ? this.enumType(row) : null,
-                enumValues: isEnum ? `${this.enumType(row)}Values` : null,
-                isArray,
-                foreignKey: associationMetadata?.foreignKey || null,
-            };
-        });
-        return Object.keys(columnData)
-            .sort()
-            .reduce((acc, key) => {
-            if (columnData[key] === undefined)
-                return acc;
-            acc[key] = columnData[key];
-            return acc;
-        }, {});
+        const dbDriverClass = Query.dbDriverClass(this.connectionName);
+        return await dbDriverClass.getColumnData(this.connectionName, tableName, associationData);
     }
     enumType(row) {
         const enumName = pascalize(row.udtName.replace(/\[\]$/, ''));
@@ -385,7 +373,7 @@ may need to update the table getter in the corresponding Dream.
     }
     async loadDbSyncFile() {
         const dreamApp = DreamApp.getOrFail();
-        const dbSyncPath = path.join(dreamApp.projectRoot, dreamApp.paths.types, 'db.ts');
+        const dbSyncPath = path.join(dreamApp.projectRoot, dreamApp.paths.types, dbTypesFilenameForConnection(this.connectionName));
         return (await fs.readFile(dbSyncPath)).toString();
     }
 }

package/dist/esm/src/helpers/cli/addImportSuffix.js

@@ -0,0 +1,14 @@
+import DreamApp from '../../dream-app/index.js';
+export default function addImportSuffix(filepath) {
+    return `${filepath.replace(/(\.ts|\.js)$/, '')}${suffix()}`;
+}
+function suffix() {
+    switch (DreamApp.getOrFail().importExtension) {
+        case '.js':
+            return '.js';
+        case '.ts':
+            return '.ts';
+        case 'none':
+            return '';
+    }
+}

package/dist/esm/src/helpers/cli/generateDream.js

@@ -19,6 +19,7 @@ export default async function generateDream({ fullyQualifiedModelName, columnsWi
             fullyQualifiedParentName,
             serializer: options.serializer,
             includeAdminSerializers: options.includeAdminSerializers,
+            connectionName: options.connectionName,
         }));
     }
     catch (error) {
@@ -43,6 +44,7 @@ export default async function generateDream({ fullyQualifiedModelName, columnsWi
     const isSTI = !!fullyQualifiedParentName;
     if (columnsWithTypes.length || !isSTI) {
         await generateMigration({
+            connectionName: options.connectionName,
             migrationName: `Create${fullyQualifiedModelName}`,
             columnsWithTypes,
             fullyQualifiedModelName,

package/dist/esm/src/helpers/cli/generateDreamContent.js

@@ -6,7 +6,8 @@ import relativeDreamPath from '../path/relativeDreamPath.js';
 import snakeify from '../snakeify.js';
 import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
 import uniq from '../uniq.js';
-export default function generateDreamContent({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, serializer, includeAdminSerializers, }) {
+import pascalize from '../pascalize.js';
+export default function generateDreamContent({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, serializer, includeAdminSerializers, connectionName = 'default', }) {
     fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
     const modelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedModelName);
     let parentModelClassName;
@@ -20,9 +21,10 @@ export default function generateDreamContent({ fullyQualifiedModelName, columnsW
         dreamImports.push('STI');
     }
     const idTypescriptType = `DreamColumn<${modelClassName}, 'id'>`;
+    const applicationModelName = connectionName === 'default' ? 'ApplicationModel' : `${pascalize(connectionName)}ApplicationModel`;
     const modelImportStatements = isSTI
         ? [importStatementForModel(fullyQualifiedModelName, fullyQualifiedParentName)]
-        : [importStatementForModel(fullyQualifiedModelName, 'ApplicationModel')];
+        : [importStatementForModel(fullyQualifiedModelName, applicationModelName)];
     const attributeStatements = columnsWithTypes.map(attribute => {
         const [attributeName, attributeType, ...descriptors] = attribute.split(':');
         if (attributeName === undefined)
@@ -78,7 +80,7 @@ import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'${uniq(modelImport
 const deco = new Decorators<typeof ${modelClassName}>()
 
 ${isSTI ? `\n@STI(${parentModelClassName})` : ''}
-export default class ${modelClassName} extends ${isSTI ? parentModelClassName : 'ApplicationModel'} {
+export default class ${modelClassName} extends ${isSTI ? parentModelClassName : applicationModelName} {
 ${isSTI
         ? ''
         : `  public override get table() {

package/dist/esm/src/helpers/cli/generateFactoryContent.js

@@ -44,27 +44,56 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
                 attributeDefaults.push(`${attributeVariable}: \`${fullyQualifiedModelName} ${attributeVariable} ${counterVariableIncremented ? '${counter}' : '${++counter}'}\`,`);
                 counterVariableIncremented = true;
                 break;
+            case 'string[]':
+            case 'text[]':
+            case 'citext[]':
+                attributeDefaults.push(`${attributeVariable}: [\`${fullyQualifiedModelName} ${attributeVariable} ${counterVariableIncremented ? '${counter}' : '${++counter}'}\`],`);
+                counterVariableIncremented = true;
+                break;
             case 'enum':
                 attributeDefaults.push(`${attributeVariable}: '${(descriptors.at(-1) || '<tbd>').split(',')[0]}',`);
                 break;
+            case 'enum[]':
+                attributeDefaults.push(`${attributeVariable}: ['${(descriptors.at(-1) || '<tbd>').split(',')[0]}'],`);
+                break;
             case 'integer':
                 attributeDefaults.push(`${attributeVariable}: 1,`);
                 break;
+            case 'integer[]':
+                attributeDefaults.push(`${attributeVariable}: [1],`);
+                break;
             case 'bigint':
                 attributeDefaults.push(`${attributeVariable}: '11111111111111111',`);
                 break;
+            case 'bigint[]':
+                attributeDefaults.push(`${attributeVariable}: ['11111111111111111'],`);
+                break;
             case 'decimal':
                 attributeDefaults.push(`${attributeVariable}: 1.1,`);
                 break;
+            case 'decimal[]':
+                attributeDefaults.push(`${attributeVariable}: [1.1],`);
+                break;
             case 'date':
                 dreamImports.push('CalendarDate');
                 attributeDefaults.push(`${attributeVariable}: CalendarDate.today(),`);
                 break;
+            case 'date[]':
+                dreamImports.push('CalendarDate');
+                attributeDefaults.push(`${attributeVariable}: [CalendarDate.today()],`);
+                break;
             case 'datetime':
                 dreamImports.push('DateTime');
                 attributeDefaults.push(`${attributeVariable}: DateTime.now(),`);
                 break;
+            case 'datetime[]':
+                dreamImports.push('DateTime');
+                attributeDefaults.push(`${attributeVariable}: [DateTime.now()],`);
+                break;
             default:
+                if (/\[\]$/.test(attributeType)) {
+                    attributeDefaults.push(`${attributeVariable}: [],`);
+                }
             // noop
         }
     }