@rvoh/dream 1.4.2 → 1.5.0

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

@@ -1,11 +1,11 @@
 import pluralize from 'pluralize-esm';
+import Query from '../../dream/Query.js';
 import InvalidDecimalFieldPassedToGenerator from '../../errors/InvalidDecimalFieldPassedToGenerator.js';
 import compact from '../compact.js';
-import foreignKeyTypeFromPrimaryKey from '../db/foreignKeyTypeFromPrimaryKey.js';
 import snakeify from '../snakeify.js';
 const STI_TYPE_COLUMN_NAME = 'type';
 const COLUMNS_TO_INDEX = [STI_TYPE_COLUMN_NAME];
-export default function generateMigrationContent({ table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', stiChildClassName, } = {}) {
+export default function generateMigrationContent({ connectionName = 'default', table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', stiChildClassName, } = {}) {
     const altering = createOrAlter === 'alter';
     let requireCitextExtension = false;
     const checkConstraints = [];
@@ -37,7 +37,7 @@ export default function generateMigrationContent({ table, columnsWithTypes = [],
         }
         switch (attributeType) {
             case 'belongs_to':
-                columnDefs.push(generateBelongsToStr(attributeName, {
+                columnDefs.push(generateBelongsToStr(connectionName, attributeName, {
                     primaryKeyType,
                     optional,
                 }));
@@ -46,15 +46,27 @@ export default function generateMigrationContent({ table, columnsWithTypes = [],
             case 'enum':
                 columnDefs.push(generateEnumStr(attributeName, { descriptors, optional }));
                 break;
+            case 'enum[]':
+                columnDefs.push(generateEnumStr(attributeName, { descriptors, optional, asArray: true }));
+                break;
             case 'decimal':
                 columnDefs.push(generateDecimalStr(attributeName, { descriptors, optional }));
                 break;
+            case 'decimal[]':
+                columnDefs.push(generateDecimalStr(attributeName, { descriptors, optional, asArray: true }));
+                break;
+            // array case for booleans can be handled with the default block.
+            // the only thing that is customized for a boolean field is the default
+            // value, which doesn't need to be special for boolean[]
             case 'boolean':
                 columnDefs.push(generateBooleanStr(attributeName, { optional }));
                 break;
             case 'encrypted':
                 columnDefs.push(generateColumnStr(`encrypted_${attributeName}`, 'text', descriptors, { optional }));
                 break;
+            // TODO: determine if we need to support encrypted[] in the future
+            case 'encrypted[]':
+                throw new Error('the "encrypted[]" column type is not supported');
             default:
                 if (sqlAttributeType !== undefined) {
                     columnDefs.push(generateColumnStr(attributeName, sqlAttributeType, descriptors, { optional }));
@@ -126,19 +138,25 @@ function getAttributeType(attributeType, descriptors) {
     switch (attributeType) {
         case 'string':
             return `varchar(${descriptors[0] || 255})`;
+        case 'string[]':
+            return `varchar(${descriptors[0] || 255})[]`;
         case 'enum':
             return enumAttributeType(descriptors);
+        case 'enum[]':
+            return enumAttributeType(descriptors, true);
         case 'datetime':
             return 'timestamp';
         default:
             return attributeType;
     }
 }
-function enumAttributeType(descriptors) {
-    return `sql\`${descriptors[0]}_enum\``;
+function enumAttributeType(descriptors, asArray = false) {
+    const suffix = asArray ? '[]' : '';
+    return `sql\`${descriptors[0]}_enum${suffix}\``;
 }
+const ENUM_OR_ENUM_ARRAY_REGEX = /:enum:.*:|:enum\[\]:.*:/;
 function generateEnumStatements(columnsWithTypes) {
-    const enumStatements = columnsWithTypes.filter(attribute => /:enum:.*:/.test(attribute));
+    const enumStatements = columnsWithTypes.filter(attribute => ENUM_OR_ENUM_ARRAY_REGEX.test(attribute));
     const finalStatements = compact(enumStatements.map(statement => {
         const [, , enumName, ...descriptors] = statement.split(':');
         optionalFromDescriptors(descriptors);
@@ -156,7 +174,7 @@ function generateEnumStatements(columnsWithTypes) {
     return finalStatements.length ? finalStatements.join('\n\n') + '\n\n' : '';
 }
 function generateEnumDropStatements(columnsWithTypes) {
-    const enumStatements = columnsWithTypes.filter(attribute => /:enum:.*:/.test(attribute));
+    const enumStatements = columnsWithTypes.filter(attribute => ENUM_OR_ENUM_ARRAY_REGEX.test(attribute));
     const finalStatements = compact(enumStatements.map(statement => {
         const [, , enumName, ...descriptors] = statement.split(':');
         optionalFromDescriptors(descriptors);
@@ -170,17 +188,22 @@ function generateEnumDropStatements(columnsWithTypes) {
 function generateBooleanStr(attributeName, { optional }) {
     return `.addColumn('${attributeName}', 'boolean'${optional ? '' : ', col => col.notNull().defaultTo(false)'})`;
 }
-function generateEnumStr(attributeName, { descriptors, optional }) {
-    const computedAttributeType = enumAttributeType(descriptors);
+function generateEnumStr(attributeName, { descriptors, optional, asArray = false }) {
+    const computedAttributeType = enumAttributeType(descriptors, asArray);
     if (attributeName === undefined)
         return '';
-    return `.addColumn('${attributeName}', ${computedAttributeType}${optional ? '' : ', col => col.notNull()'})`;
+    const columnModifiers = asArray ? "col.notNull().defaultTo('{}')" : 'col.notNull()';
+    return `.addColumn('${attributeName}', ${computedAttributeType}${optional ? '' : `, col => ${columnModifiers}`})`;
 }
-function generateDecimalStr(attributeName, { descriptors, optional }) {
+function generateDecimalStr(attributeName, { descriptors, optional, asArray = false }) {
     const [scale, precision] = descriptors[0]?.split(',') || [null, null];
     if (!scale || !precision)
         throw new InvalidDecimalFieldPassedToGenerator(attributeName);
-    return `.addColumn('${attributeName}', 'decimal(${scale}, ${precision})'${optional ? '' : ', col => col.notNull()'})`;
+    const columnModifiers = asArray ? "col.notNull().defaultTo('{}')" : 'col.notNull()';
+    const decimalStatement = asArray
+        ? `sql\`decimal(${scale}, ${precision})[]\``
+        : `'decimal(${scale}, ${precision})'`;
+    return `.addColumn('${attributeName}', ${decimalStatement}${optional ? '' : `, col => ${columnModifiers}`})`;
 }
 function generateColumnStr(attributeName, attributeType, descriptors, { optional }) {
     let returnStr = `.addColumn('${attributeName}', ${attributeTypeString(attributeType)}`;
@@ -188,12 +211,15 @@ function generateColumnStr(attributeName, attributeType, descriptors, { optional
     const providedDefault = providedDefaultArg?.replace(/^default\(/, '')?.replace(/\)$/, '');
     const notNull = !optional;
     const hasExtraValues = providedDefault || notNull;
+    const isArray = /\[\]$/.test(attributeType);
     if (hasExtraValues)
         returnStr += ', col => col';
     if (notNull)
         returnStr += '.notNull()';
     if (providedDefault)
         returnStr += `.defaultTo('${providedDefault}')`;
+    else if (isArray)
+        returnStr += `.defaultTo('{}')`;
     returnStr = `${returnStr})`;
     if (attributeName === STI_TYPE_COLUMN_NAME)
         returnStr = `// CONSIDER: when using type for STI, always use an enum
@@ -206,6 +232,7 @@ function attributeTypeString(attributeType) {
     const attributeTypesRequiringSql = ['citext'];
     if (attributeTypesRequiringSql.includes(attributeType))
         return `sql\`${attributeType}\``;
+    const isArray = /\[\]$/.test(attributeType);
     switch (attributeType) {
         case 'varbit':
         case 'bitvarying':
@@ -213,11 +240,17 @@ function attributeTypeString(attributeType) {
         case 'txid_snapshot':
             return "'txid_snapshot'";
         default:
-            return `'${attributeType.replace(/_/g, ' ')}'`;
+            if (isArray) {
+                return `sql\`${attributeType.replace(/_/g, ' ')}\``;
+            }
+            else {
+                return `'${attributeType.replace(/_/g, ' ')}'`;
+            }
     }
 }
-function generateBelongsToStr(associationName, { primaryKeyType, optional = false, }) {
-    const dataType = foreignKeyTypeFromPrimaryKey(primaryKeyType);
+function generateBelongsToStr(connectionName, associationName, { primaryKeyType, optional = false, }) {
+    const dbDriverClass = Query.dbDriverClass(connectionName);
+    const dataType = dbDriverClass.foreignKeyTypeFromPrimaryKey(primaryKeyType);
     const references = pluralize(associationName.replace(/\//g, '_').replace(/_id$/, ''));
     return `.addColumn('${associationNameToForeignKey(associationName)}', '${dataType}', col => col.references('${references}.id').onDelete('restrict')${optional ? '' : '.notNull()'})`;
 }

package/dist/esm/src/helpers/db/primaryKeyType.js

@@ -1,23 +1,5 @@
-import DreamApp from '../../dream-app/index.js';
-import { primaryKeyTypes } from '../../dream/constants.js';
-export default function primaryKeyType() {
-    const dreamconf = DreamApp.getOrFail();
-    switch (dreamconf.primaryKeyType) {
-        case 'bigint':
-        case 'bigserial':
-        case 'uuid':
-        case 'integer':
-            return dreamconf.primaryKeyType;
-        default: {
-            // protection so that if a new EncryptAlgorithm is ever added, this will throw a type error at build time
-            const _never = dreamconf.primaryKeyType;
-            throw new Error(`
-ATTENTION!
-
-  unrecognized primary key type "${_never}" found in .dream.yml.
-  please use one of the allowed primary key types:
-    ${primaryKeyTypes.join(', ')}
-      `);
-        }
-    }
+import Query from '../../dream/Query.js';
+export default function primaryKeyType(connectionName) {
+    const dbDriverClass = Query.dbDriverClass(connectionName);
+    return dbDriverClass.primaryKeyType();
 }

package/dist/esm/src/helpers/sqlAttributes.js

@@ -1,3 +1,4 @@
+import DreamApp from '../dream-app/index.js';
 import CalendarDate from './CalendarDate.js';
 import { DateTime } from './DateTime.js';
 import isDatetimeOrDatetimeArrayColumn from './db/types/isDatetimeOrDatetimeArrayColumn.js';
@@ -6,6 +7,7 @@ import normalizeUnicode from './normalizeUnicode.js';
 export default function sqlAttributes(dream) {
     const attributes = dream.dirtyAttributes();
     const dreamClass = dream.constructor;
+    const queryDriverClass = DreamApp.getOrFail().dbConnectionQueryDriverClass(dream.connectionName);
     return Object.keys(attributes).reduce((result, key) => {
         let val = attributes[key];
         if (val === undefined)
@@ -23,13 +25,14 @@ export default function sqlAttributes(dream) {
                 val = normalizeUnicode(val);
         }
         if (val instanceof DateTime || val instanceof CalendarDate) {
+            const dateOrDatetime = val instanceof DateTime ? 'datetime' : 'date';
             // Converting toJSDate resulted in the correct timezone, but even with process.env.TZ=UTC,
             // Kysely inserted into the database with the machine timezone, which can shift the date
             // (e.g., toJSDate resulted in a JS Date that formats as "1987-04-07T00:00:00.000Z", but
             // Kysely inserted "1907-04-06"  into the database). By converting to an SQL string before
             // handing off to Kysely, we bypass Javascript dates altogether, sending the string into the
             // database for storage as a date or datetime.
-            result[key] = val.toSQL();
+            result[key] = queryDriverClass.serializeDbType(dateOrDatetime, val);
         }
         else {
             result[key] = val;

package/dist/esm/src/index.js

@@ -18,6 +18,9 @@ export { default as Dream } from './Dream.js';
 export { DreamConst, openapiPrimitiveTypes, openapiShorthandPrimitiveTypes, } from './dream/constants.js';
 export { default as DreamTransaction } from './dream/DreamTransaction.js';
 export { default as Query } from './dream/Query.js';
+export { default as QueryDriverBase } from './dream/QueryDriver/Base.js';
+export { default as KyselyQueryDriver } from './dream/QueryDriver/Kysely.js';
+export { default as PostgresQueryDriver } from './dream/QueryDriver/Postgres.js';
 export { default as Encrypt } from './encrypt/index.js';
 export { default as NonLoadedAssociation } from './errors/associations/NonLoadedAssociation.js';
 export { default as CreateOrFindByFailedToCreateAndFind } from './errors/CreateOrFindByFailedToCreateAndFind.js';

package/dist/types/src/Dream.d.ts

@@ -8,7 +8,7 @@ import LoadBuilder from './dream/LoadBuilder.js';
 import Query from './dream/Query.js';
 import { PassthroughOnClause, WhereStatement } from './types/associations/shared.js';
 import { AssociationTableNames, DbConnectionType } from './types/db.js';
-import { AllDefaultScopeNames, AssociationNameToDream, AttributeKeys, CreateOrFindByExtraOpts, DefaultOrNamedScopeName, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, DreamColumnNames, DreamParamSafeColumnNames, DreamPrimaryKeyType, DreamSerializerKey, JoinAndStatements, NextPreloadArgumentType, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableAssociationProperties, UpdateableProperties, UpdateablePropertiesForClass, UpdateOrCreateByExtraOpts } from './types/dream.js';
+import { AllDefaultScopeNames, AssociationNameToDream, AttributeKeys, CreateOrFindByExtraOpts, DefaultOrNamedScopeName, DreamAssociationNames, DreamAssociationNamesWithoutRequiredOnClauses, DreamAttributes, DreamColumnNames, DreamParamSafeColumnNames, DreamPrimaryKeyType, DreamSerializerKey, GlobalModelNames, GlobalSerializerName, JoinAndStatements, NextPreloadArgumentType, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, TableColumnNames, UpdateableAssociationProperties, UpdateableProperties, UpdateablePropertiesForClass, UpdateOrCreateByExtraOpts } from './types/dream.js';
 import { BaseModelColumnTypes, DefaultQueryTypeOptions, FindEachOpts, LoadForModifierFn, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryWithJoinedAssociationsType, QueryWithJoinedAssociationsTypeAndNoPreload } from './types/query.js';
 import { DreamModelSerializerType, SimpleObjectSerializerType } from './types/serializer.js';
 import { ValidationType } from './types/validation.js';
@@ -50,7 +50,9 @@ export default class Dream {
      */
     private static globallyInitializingDecorators;
     get schema(): any;
-    get globalSchema(): any;
+    get connectionName(): any;
+    get connectionTypeConfig(): any;
+    get globalTypeConfig(): any;
     /**
      * Determines if the provided Dream class is the same as or a subclass of this Dream class.
      * This method is particularly useful for runtime type checking and works with STI (Single Table Inheritance) classes.
@@ -564,7 +566,7 @@ export default class Dream {
      *
      * @returns the found model or serializer, depending on what you are looking for
      */
-    static lookup<T extends typeof Dream, GlobalSchema = InstanceType<T>['globalSchema'], GlobalNames = GlobalSchema['globalNames' & keyof GlobalSchema], ModelGlobalNames = keyof GlobalNames['models' & keyof GlobalNames], SerializerGlobalNames = (GlobalNames['serializers' & keyof GlobalNames] & unknown[])[number], LookupName extends SerializerGlobalNames | ModelGlobalNames = SerializerGlobalNames | ModelGlobalNames>(this: T, lookupName: LookupName): typeof Dream | DreamModelSerializerType | SimpleObjectSerializerType | undefined;
+    static lookup<T extends typeof Dream, LookupName extends GlobalSerializerName<InstanceType<T>> | GlobalModelNames<InstanceType<T>> = GlobalSerializerName<InstanceType<T>> | GlobalModelNames<InstanceType<T>>>(this: T, lookupName: LookupName): typeof Dream | DreamModelSerializerType | SimpleObjectSerializerType | undefined;
     /**
      * Prevents a specific default scope from applying when
      * the Query is executed

package/dist/types/src/bin/index.d.ts

@@ -11,10 +11,12 @@ export default class DreamBin {
     static generateDream(fullyQualifiedModelName: string, columnsWithTypes: string[], options: {
         serializer: boolean;
         stiBaseSerializer: boolean;
+        connectionName: string;
     }): Promise<void>;
     static generateStiChild(fullyQualifiedModelName: string, fullyQualifiedParentName: string, columnsWithTypes: string[], options: {
         serializer: boolean;
+        connectionName: string;
     }): Promise<void>;
-    static generateMigration(migrationName: string, columnsWithTypes: string[]): Promise<void>;
+    static generateMigration(migrationName: string, columnsWithTypes: string[], connectionName: string): Promise<void>;
     private static buildDocs;
 }

package/dist/types/src/db/ConnectedToDB.d.ts

@@ -1,4 +1,3 @@
-import { Kysely, Transaction as KyselyTransaction } from 'kysely';
 import Dream from '../Dream.js';
 import DreamTransaction from '../dream/DreamTransaction.js';
 import { DbConnectionType } from '../types/db.js';
@@ -16,7 +15,6 @@ export default class ConnectedToDB<DreamInstance extends Dream> {
     protected readonly innerJoinDreamClasses: readonly (typeof Dream)[];
     constructor(dreamInstance: DreamInstance, opts?: ConnectedToDBOpts);
     dbConnectionType(sqlCommandType: SqlCommandType): DbConnectionType;
-    dbFor(sqlCommandType: SqlCommandType): Kysely<DreamInstance['DB']> | KyselyTransaction<DreamInstance['DB']>;
     private isReplicaSafe;
 }
 export interface ConnectedToDBOpts {

package/dist/types/src/db/DreamDbConnection.d.ts

@@ -1,11 +1,15 @@
 import { Kysely } from 'kysely';
+import { SingleDbCredential } from '../dream-app/index.js';
 import { DbConnectionType } from '../types/db.js';
 export default class DreamDbConnection {
-    static getConnection<DB>(connectionType: DbConnectionType): Kysely<DB>;
-    static dropAllConnections(): Promise<void>;
+    static getConnection<DB>(connectionName: string, connectionType: DbConnectionType, dialectProvider: DialectProviderCb): Kysely<DB>;
     private static getConnectionTypeName;
 }
 export declare function dreamDbConnections(): {
-    [key: string]: Kysely<any>;
+    [key: string]: {
+        [key: string]: Kysely<any>;
+    };
 };
 export declare function closeAllDbConnections(): Promise<void>;
+export declare function closeAllConnectionsForConnectionName(connectionName: string): Promise<PromiseSettledResult<void>[]>;
+export type DialectProviderCb = (connectionConf: SingleDbCredential) => any;

package/dist/types/src/db/helpers/dbTypesFilenameForConnection.d.ts

@@ -0,0 +1 @@
+export default function dbTypesFilenameForConnection(connectionName: string): string;

package/dist/types/src/db/helpers/syncDbTypesFiles.d.ts

@@ -0,0 +1 @@
+export default function syncDbTypesFiles(connectionName: string): Promise<void>;

package/dist/types/src/db/index.d.ts

@@ -1,4 +1,5 @@
 import { Kysely } from 'kysely';
+import { SingleDbCredential } from '../dream-app/index.js';
 import Dream from '../Dream.js';
 import { DbConnectionType } from '../types/db.js';
-export default function db<T extends Dream, DB extends T['DB'] = T['DB']>(connectionType?: DbConnectionType): Kysely<DB>;
+export default function db<T extends Dream, DB extends T['DB'] = T['DB']>(connectionName?: string, connectionType?: DbConnectionType, dialectProvider?: (connectionConf: SingleDbCredential) => any): Kysely<DB>;

package/dist/types/src/decorators/field/sortable/helpers/setPosition.d.ts

@@ -2,6 +2,7 @@ import { SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
 import Dream from '../../../../Dream.js';
 import DreamTransaction from '../../../../dream/DreamTransaction.js';
 import Query from '../../../../dream/Query.js';
+import PostgresQueryDriver from '../../../../dream/QueryDriver/Postgres.js';
 export default function setPosition({ position, previousPosition, dream, positionField, scope, query, txn, }: {
     dream: Dream;
     position: number;
@@ -12,3 +13,4 @@ export default function setPosition({ position, previousPosition, dream, positio
     txn: DreamTransaction<any> | undefined;
 }): Promise<void>;
 export declare function applySortableScopesToQuery<QB extends UpdateQueryBuilder<any, string, string, any> | SelectQueryBuilder<any, any, any>>(dream: Dream, kyselyQuery: QB, whereValueCB: (column: string) => any, scope?: string | string[]): QB;
+export declare function getPostgresQueryDriver(connectionName: string): typeof PostgresQueryDriver;

package/dist/types/src/dream/Query.d.ts

@@ -6,7 +6,7 @@ import { AllDefaultScopeNames, DefaultScopeName, DreamColumnNames, DreamConstruc
 import { DefaultQueryTypeOptions, ExtendQueryType, LoadForModifierFn, NamespacedOrBaseModelColumnTypes, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, QueryTypeOptions, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
-import PostgresQueryDriver from './QueryDriver/Postgres.js';
+import QueryDriverBase from './QueryDriver/Base.js';
 export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Readonly<QueryTypeOptions> = DefaultQueryTypeOptions<DreamInstance>> {
     /**
      * @internal
@@ -705,9 +705,7 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * @returns An object representing the underlying sql statement
      *
      */
-    sql(): import("kysely").CompiledQuery<{
-        [x: string]: any;
-    }>;
+    sql(): import("kysely").CompiledQuery<object>;
     /**
      * Converts the given dream class into a Kysely query, enabling
      * you to build custom queries using the Kysely API
@@ -843,22 +841,9 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
     all(options?: {
         columns?: DreamColumnNames<DreamInstance>[];
     }): Promise<DreamInstance[]>;
-    static dbDriverClass<T extends Dream>(): {
-        new (query: Query<T, any>): PostgresQueryDriver<T>;
-        migrate(): Promise<void>;
-        rollback(opts: {
-            steps: number;
-        }): Promise<void>;
-        generateMigration(migrationName: string, columnsWithTypes: string[]): Promise<void>;
-        sync(onSync: () => Promise<void> | void, options?: {
-            schemaOnly?: boolean;
-        }): Promise<void>;
-        dbCreate(): Promise<void>;
-        dbDrop(): Promise<void>;
-        saveDream(dream: Dream, txn?: DreamTransaction<Dream> | null): Promise<any>;
-        duplicateDatabase(): Promise<void>;
-    };
-    dbDriverInstance(query?: Query<DreamInstance, any>): PostgresQueryDriver<DreamInstance>;
+    static dbDriverClass<T extends Dream>(connectionName: string): typeof QueryDriverBase<T>;
+    dbDriverInstance(query?: Query<DreamInstance, any>): QueryDriverBase<DreamInstance>;
+    get connectionName(): any;
     /**
      * 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

package/dist/types/src/dream/QueryDriver/Base.d.ts

@@ -1,12 +1,12 @@
-import { DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
+import { CompiledQuery, DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
 import Dream from '../../Dream.js';
+import { SchemaBuilderAssociationData, SchemaBuilderColumnData } from '../../helpers/cli/SchemaBuilder.js';
 import { AssociationStatement } from '../../types/associations/shared.js';
-import { DreamColumnNames, DreamConstructorType, DreamTableSchema } from '../../types/dream.js';
+import { DbConnectionType } from '../../types/db.js';
+import { DreamColumnNames, DreamConstructorType, DreamTableSchema, PrimaryKeyType } from '../../types/dream.js';
 import { PreloadedDreamsAndWhatTheyPointTo, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../../types/query.js';
 import DreamTransaction from '../DreamTransaction.js';
 import Query from '../Query.js';
-import PostgresQueryDriver from './Postgres.js';
-import { DbConnectionType } from '../../types/db.js';
 export default class QueryDriverBase<DreamInstance extends Dream> {
     query: Query<DreamInstance, any>;
     protected readonly dreamClass: DreamConstructorType<DreamInstance>;
@@ -23,21 +23,22 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
     /**
      * migrate the database. Must respond to the NODE_ENV value.
      */
-    static migrate(): Promise<void>;
+    static migrate(connectionName: string): Promise<void>;
     /**
      * rollback the database. Must respond to the NODE_ENV value.
      */
     static rollback(_: {
+        connectionName: string;
         steps: number;
     }): Promise<void>;
     /**
      * create the database. Must respond to the NODE_ENV value.
      */
-    static dbCreate(): Promise<void>;
+    static dbCreate(connectionName: string): Promise<void>;
     /**
      * delete the database. Must respond to the NODE_ENV value.
      */
-    static dbDrop(): Promise<void>;
+    static dbDrop(connectionName: string): Promise<void>;
     /**
      * This should build a new migration file in the migrations folder
      * of your application. This will then need to be read and run
@@ -46,7 +47,7 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * is sorted by date in the file tree, and, more importantly, so
      * they can be run in order by your migration runner.
      */
-    static generateMigration(migrationName: string, columnsWithTypes: string[]): Promise<void>;
+    static generateMigration(connectionName: string, migrationName: string, columnsWithTypes: string[]): Promise<void>;
     /**
      * defines the syncing behavior for dream and psychic,
      * which is run whenever the `sync` command is called.
@@ -63,7 +64,9 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      *    but this will likely need to be overridden to tailor to your custom
      *    database engine.
      */
-    static sync(_: () => Promise<void> | void): Promise<void>;
+    static sync(connectionName: string, _: () => Promise<void> | void, options?: {
+        schemaOnly?: boolean;
+    }): Promise<void>;
     /**
      * Converts the given dream class into a Kysely query, enabling
      * you to build custom queries using the Kysely API
@@ -76,6 +79,53 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * @returns A Kysely query. Depending on the type passed, it will return either a SelectQueryBuilder, DeleteQueryBuilder, or an UpdateQueryBuilder
      */
     toKysely<QueryType extends 'select' | 'delete' | 'update', DbType = QueryToKyselyDBType<Query<DreamInstance>>, TableNames = QueryToKyselyTableNamesType<Query<DreamInstance>>, ToKyselyReturnType = QueryType extends 'select' ? SelectQueryBuilder<DbType, TableNames & keyof DbType, unknown> : QueryType extends 'delete' ? DeleteQueryBuilder<DbType, TableNames & keyof DbType, unknown> : QueryType extends 'update' ? UpdateQueryBuilder<DbType, TableNames & keyof DbType, TableNames & keyof DbType, unknown> : never>(type: QueryType): ToKyselyReturnType;
+    /**
+     * 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
+     */
+    static transaction<DreamInstance extends Dream, CB extends (txn: DreamTransaction<DreamInstance>) => unknown, RetType extends ReturnType<CB>>(dreamInstance: DreamInstance, callback: CB): Promise<RetType>;
+    /**
+     * @internal
+     *
+     * returns the foreign key type based on the primary key received.
+     * gives the driver the opportunity to switch i.e. bigserial to bigint.
+     */
+    static foreignKeyTypeFromPrimaryKey(primaryKey: PrimaryKeyType): PrimaryKeyType;
+    /**
+     * @internal
+     *
+     * used to return the computed primary key type based
+     * on the primaryKeyType set in the DreamApp class.
+     */
+    static primaryKeyType(): void;
+    /**
+     * @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
+     */
+    static setDatabaseTypeParsers(connectionName: string): Promise<void>;
+    static duplicateDatabase(connectionName: string): Promise<void>;
+    static getColumnData(connectionName: string, tableName: string, associationData: {
+        [key: string]: SchemaBuilderAssociationData;
+    }): Promise<{
+        [key: string]: SchemaBuilderColumnData;
+    }>;
+    static serializeDbType(type: GenericDbType, val: any): any;
     /**
      * @internal
      *
@@ -100,7 +150,7 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      *
      * @returns A dream instance or null
      */
-    takeOne(this: PostgresQueryDriver<DreamInstance>): Promise<DreamInstance | null>;
+    takeOne(this: QueryDriverBase<DreamInstance>): Promise<DreamInstance | null>;
     /**
      * Retrieves an array containing all records matching the Query.
      * Be careful using this, since it will attempt to pull every
@@ -176,7 +226,7 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * @param selection - the column to use for your nested Query
      * @returns A Kysely SelectQueryBuilder instance
      */
-    nestedSelect<SimpleFieldType extends keyof DreamColumnNames<DreamInstance>, PluckThroughFieldType>(this: PostgresQueryDriver<DreamInstance>, selection: SimpleFieldType | PluckThroughFieldType): void;
+    nestedSelect<SimpleFieldType extends keyof DreamColumnNames<DreamInstance>, PluckThroughFieldType>(this: QueryDriverBase<DreamInstance>, selection: SimpleFieldType | PluckThroughFieldType): SelectQueryBuilder<any, any, any>;
     /**
      * executes provided query instance as a deletion query.
      * @returns the number of deleted rows
@@ -193,7 +243,17 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * to encapsulate the persisting of the dream, as well as any
      * subsequent model hooks that are fired.
      */
-    static saveDream(dream: Dream, txn?: DreamTransaction<Dream> | null): Promise<void>;
+    static saveDream(dream: Dream, txn?: DreamTransaction<Dream> | null): Promise<any>;
+    /**
+     * 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
+     */
+    static destroyDream(dream: Dream, txn: DreamTransaction<Dream>, reallyDestroy: boolean): Promise<void>;
+    static get syncDialect(): string;
     /**
      * Returns the sql that would be executed by this Query
      *
@@ -226,7 +286,7 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * @returns An object representing the underlying sql statement
      *
      */
-    sql(): void;
+    sql(): CompiledQuery<object>;
     /**
      * @internal
      *
@@ -240,3 +300,4 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      */
     hydratePreload(this: QueryDriverBase<DreamInstance>, dream: Dream): Promise<void>;
 }
+export type GenericDbType = 'datetime' | 'date';