@rvoh/dream 1.0.4 → 1.0.5

package/dist/esm/src/dream/QueryDriver/Kysely.js

@@ -1,12 +1,14 @@
 import { sql, } from 'kysely';
 import pluralize from 'pluralize-esm';
 import writeSyncFile from '../../bin/helpers/sync.js';
+import { CliFileWriter } from '../../cli/CliFileWriter.js';
 import DreamCLI from '../../cli/index.js';
 import _db from '../../db/index.js';
 import associationToGetterSetterProp from '../../decorators/field/association/associationToGetterSetterProp.js';
 import PackageManager from '../../dream-app/helpers/PackageManager.js';
 import DreamApp from '../../dream-app/index.js';
-import CannotAssociateThroughPolymorphic from '../../errors/associations/CannotAssociateThroughPolymorphic.js';
+import ArrayTargetsIncompatibleWithThroughAssociation from '../../errors/associations/ArrayTargetsIncompatibleWithThroughAssociation.js';
+import CannotAssociateThroughMultiplePolymorphics from '../../errors/associations/CannotAssociateThroughMultiplePolymorphics.js';
 import CannotJoinPolymorphicBelongsToError from '../../errors/associations/CannotJoinPolymorphicBelongsToError.js';
 import JoinAttemptedOnMissingAssociation from '../../errors/associations/JoinAttemptedOnMissingAssociation.js';
 import MissingRequiredAssociationAndClause from '../../errors/associations/MissingRequiredAssociationAndClause.js';
@@ -92,33 +94,41 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         await generateMigration({ migrationName, columnsWithTypes });
     }
     static async sync(onSync, options = {}) {
-        if (!options?.schemaOnly) {
-            DreamCLI.logger.logStartProgress('writing db schema...');
-            await writeSyncFile();
-            DreamCLI.logger.logEndProgress();
-        }
-        DreamCLI.logger.logStartProgress('building dream schema...');
-        const schemaBuilder = new SchemaBuilder();
-        await schemaBuilder.build();
-        DreamCLI.logger.logEndProgress();
-        if (schemaBuilder.hasForeignKeyError && !options?.schemaOnly) {
-            DreamCLI.logger.logStartProgress('triggering resync to correct for foreign key errors...');
-            // TODO: make this customizable to enable dream apps to separate
-            const cliCmd = EnvInternal.boolean('DREAM_CORE_DEVELOPMENT') ? 'dream' : 'psy';
-            await DreamCLI.spawn(PackageManager.runCmd(`${cliCmd} sync --schema-only`), {
-                onStdout: str => {
-                    DreamCLI.logger.logContinueProgress(`${str}`, {
-                        logPrefix: '  ├ [resync]',
-                        logPrefixColor: 'blue',
-                    });
-                },
+        try {
+            if (!options?.schemaOnly) {
+                await DreamCLI.logger.logProgress('writing db schema...', async () => {
+                    await writeSyncFile();
+                });
+            }
+            const schemaBuilder = new SchemaBuilder();
+            await DreamCLI.logger.logProgress('building dream schema...', async () => {
+                await schemaBuilder.build();
             });
-            DreamCLI.logger.logEndProgress();
+            if (schemaBuilder.hasForeignKeyError && !options?.schemaOnly) {
+                await DreamCLI.logger.logProgress('triggering resync to correct for foreign key errors...', async () => {
+                    // TODO: make this customizable to enable dream apps to separate
+                    const cliCmd = EnvInternal.boolean('DREAM_CORE_DEVELOPMENT') ? 'dream' : 'psy';
+                    await DreamCLI.spawn(PackageManager.runCmd(`${cliCmd} sync --schema-only`), {
+                        onStdout: str => {
+                            DreamCLI.logger.logContinueProgress(`${str}`, {
+                                logPrefix: '  ├ [resync]',
+                                logPrefixColor: 'blue',
+                            });
+                        },
+                    });
+                });
+            }
+            if (!options?.schemaOnly) {
+                // intentionally leaving logs off here, since it allows other
+                // onSync handlers to determine their own independent logging approach
+                await onSync();
+            }
         }
-        if (!options?.schemaOnly) {
-            // intentionally leaving logs off here, since it allows other
-            // onSync handlers to determine their own independent logging approach
-            await onSync();
+        catch (error) {
+            console.error(error);
+            await DreamCLI.logger.logProgress('sync failed, reverting file contents...', async () => {
+                await CliFileWriter.revert();
+            });
         }
     }
     /**
@@ -1087,6 +1097,8 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 currentAssociationTableOrAlias,
                 joinAndStatements,
                 joinType,
+                baseThroughAssociation: undefined,
+                polymorphicCount: { count: 0 },
             });
             query = results.query;
             const association = results.association;
@@ -1282,7 +1294,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      * the `through` association are only added when the recursion returns
      * back to the association that kicked off the through associations.
      */
-    joinsBridgeThroughAssociations({ query, dreamClass, association, previousAssociationTableOrAlias, throughAssociations, joinType, }) {
+    joinsBridgeThroughAssociations({ query, dreamClass, association, previousAssociationTableOrAlias, throughAssociations, joinType, baseThroughAssociation, polymorphicCount, }) {
         if (association.type === 'BelongsTo' || !association.through) {
             return {
                 query,
@@ -1305,6 +1317,8 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 currentAssociationTableOrAlias: association.through,
                 throughAssociations,
                 joinType,
+                baseThroughAssociation,
+                polymorphicCount,
             });
             // The through association has both a `through` and a `source`. The `source`
             // is the association on the model that has now been joined. In our example,
@@ -1320,6 +1334,8 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     previousAssociationTableOrAlias: throughAssociation.as,
                     throughAssociations,
                     joinType,
+                    baseThroughAssociation,
+                    polymorphicCount,
                 });
             }
             else {
@@ -1349,7 +1365,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             });
         const throughClass = throughAssociation.modelCB();
         if (Array.isArray(throughClass))
-            throw new CannotAssociateThroughPolymorphic({
+            throw new ArrayTargetsIncompatibleWithThroughAssociation({
                 dreamClass,
                 association,
             });
@@ -1373,18 +1389,23 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      * the `through` association are only added when the recursion returns
      * back to the association that kicked off the through associations.
      */
-    applyOneJoin({ query, dreamClass, previousAssociationTableOrAlias, currentAssociationTableOrAlias, joinAndStatements = {}, throughAssociations = [], joinType, }) {
+    applyOneJoin({ query, dreamClass, previousAssociationTableOrAlias, currentAssociationTableOrAlias, joinAndStatements = {}, throughAssociations = [], joinType, baseThroughAssociation, polymorphicCount, }) {
         const { name, alias } = extractAssociationMetadataFromAssociationName(currentAssociationTableOrAlias);
         const joinAndStatement = joinAndStatements[currentAssociationTableOrAlias];
         previousAssociationTableOrAlias = extractAssociationMetadataFromAssociationName(previousAssociationTableOrAlias).alias;
         currentAssociationTableOrAlias = alias;
         let association = dreamClass['getAssociationMetadata'](name);
+        if (association?.polymorphic)
+            polymorphicCount.count++;
         if (!association) {
             throw new JoinAttemptedOnMissingAssociation({
                 dreamClass,
                 associationName: currentAssociationTableOrAlias,
             });
         }
+        baseThroughAssociation ??= association.through
+            ? association
+            : undefined;
         const results = this.joinsBridgeThroughAssociations({
             query,
             dreamClass,
@@ -1392,11 +1413,23 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             previousAssociationTableOrAlias,
             throughAssociations,
             joinType,
+            baseThroughAssociation,
+            polymorphicCount,
         });
         query = results.query;
         dreamClass = results.dreamClass;
         association = results.association;
+        if (association?.polymorphic)
+            polymorphicCount.count++;
         const timeToApplyThroughAssociations = throughAssociations.length && throughAssociations[0]?.source === association.as;
+        const baseThroughAssociationToApply = association.polymorphic ? baseThroughAssociation : undefined;
+        if (baseThroughAssociationToApply && polymorphicCount.count > 1)
+            throw new CannotAssociateThroughMultiplePolymorphics({
+                dreamClass,
+                association,
+                innerJoinStatements: this.query['innerJoinStatements'],
+                leftJoinStatements: this.query['leftJoinStatements'],
+            });
         const originalPreviousAssociationTableOrAlias = previousAssociationTableOrAlias;
         previousAssociationTableOrAlias = results.previousAssociationTableOrAlias;
         const throughClass = results.throughClass;
@@ -1434,19 +1467,34 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             });
         }
         if (association.type === 'BelongsTo') {
-            if (Array.isArray(association.modelCB()))
+            if (!baseThroughAssociationToApply && Array.isArray(association.modelCB()))
                 throw new CannotJoinPolymorphicBelongsToError({
                     dreamClass,
                     association,
                     innerJoinStatements: this.query['innerJoinStatements'],
                     leftJoinStatements: this.query['leftJoinStatements'],
                 });
-            const to = association.modelCB().table;
+            const to = (baseThroughAssociationToApply ?? association).modelCB().table;
             const joinTableExpression = currentAssociationTableOrAlias === to
                 ? currentAssociationTableOrAlias
                 : `${to} as ${currentAssociationTableOrAlias}`;
             query = query[(joinType === 'inner' ? 'innerJoin' : 'leftJoin')](joinTableExpression, (join) => {
-                join = join.onRef(this.namespaceColumn(association.foreignKey(), previousAssociationTableOrAlias), '=', this.namespaceColumn(association.primaryKey(), currentAssociationTableOrAlias));
+                join = join.onRef(this.namespaceColumn(association.foreignKey(), previousAssociationTableOrAlias), '=', this.namespaceColumn(association.primaryKey(undefined, {
+                    associatedClassOverride: baseThroughAssociationToApply?.modelCB(),
+                }), currentAssociationTableOrAlias));
+                if (baseThroughAssociationToApply) {
+                    /**
+                     * At this point, all `through` associations have been bridged and a
+                     * real association has been reached that is a polymorphic BelongsTo (it
+                     * is polymorphic and has an array of target models). Join with that
+                     * table conditionally based on the polymorphic foreign key type,
+                     * namespaced to the name of that association (which we know from the
+                     * target of the final `through` association)
+                     */
+                    join = join.on((eb) => this.whereStatementToExpressionWrapper(eb, this.aliasWhereStatement({
+                        [association.foreignKeyTypeField()]: baseThroughAssociationToApply.modelCB().sanitizedName,
+                    }, throughAssociations.at(-1).through)));
+                }
                 if (timeToApplyThroughAssociations) {
                     throughAssociations.forEach((throughAssociation) => {
                         join = this.applyAssociationAndStatementsToJoinStatement({
@@ -1462,6 +1510,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     join,
                     tableNameOrAlias: currentAssociationTableOrAlias,
                     association,
+                    throughAssociatedClassOverride: baseThroughAssociationToApply?.modelCB(),
                 });
                 join = this.applyJoinAndStatement(join, joinAndStatement, currentAssociationTableOrAlias);
                 return join;
@@ -1503,6 +1552,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     join,
                     tableNameOrAlias: currentAssociationTableOrAlias,
                     association,
+                    throughAssociatedClassOverride: baseThroughAssociationToApply?.modelCB(),
                 });
                 join = this.applyJoinAndStatement(join, joinAndStatement, currentAssociationTableOrAlias);
                 return join;
@@ -1592,9 +1642,9 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         if (missingRequiredWhereStatements.length)
             throw new MissingRequiredAssociationAndClause(association, missingRequiredWhereStatements[0]);
     }
-    conditionallyApplyDefaultScopesDependentOnAssociation({ join, tableNameOrAlias, association, }) {
+    conditionallyApplyDefaultScopesDependentOnAssociation({ join, tableNameOrAlias, association, throughAssociatedClassOverride, }) {
         let scopesQuery = new Query(this.dreamInstance);
-        const associationClass = association.modelCB();
+        const associationClass = throughAssociatedClassOverride ?? association.modelCB();
         const associationScopes = associationClass['scopes'].default;
         for (const scope of associationScopes) {
             if (!shouldBypassDefaultScope(scope.method, {

package/dist/esm/src/errors/associations/ArrayTargetsIncompatibleWithThroughAssociation.js

@@ -0,0 +1,16 @@
+export default class ArrayTargetsIncompatibleWithThroughAssociation extends Error {
+    dreamClass;
+    association;
+    constructor({ dreamClass, association, }) {
+        super();
+        this.dreamClass = dreamClass;
+        this.association = association;
+    }
+    get message() {
+        return `
+Through associations may not define an array of targets:
+Dream class: ${this.dreamClass.sanitizedName}
+Association: ${this.association.as}
+`;
+    }
+}

package/dist/esm/src/errors/associations/CannotAssociateThroughMultiplePolymorphics.js

@@ -0,0 +1,24 @@
+export default class CannotAssociateThroughMultiplePolymorphics extends Error {
+    dreamClass;
+    association;
+    innerJoinStatements;
+    leftJoinStatements;
+    constructor({ dreamClass, association, innerJoinStatements, leftJoinStatements, }) {
+        super();
+        this.dreamClass = dreamClass;
+        this.association = association;
+        this.innerJoinStatements = innerJoinStatements;
+        this.leftJoinStatements = leftJoinStatements;
+    }
+    get message() {
+        return `
+Cannot associate through multiple polymorphic associations if one of them is a BelongsTo:
+Dream class: ${this.dreamClass.sanitizedName}
+Association: ${this.association.as}
+Inner Join statements:
+${JSON.stringify(this.innerJoinStatements, null, 2)}
+Left Join statements:
+${JSON.stringify(this.leftJoinStatements, null, 2)}
+    `;
+    }
+}

package/dist/esm/src/errors/associations/MissingThroughAssociationSource.js

@@ -14,7 +14,7 @@ export default class MissingThroughAssociationSource extends Error {
 
 \`${this.dreamClass.sanitizedName}\` association \`${this.association.through}\` points to \`${this.throughClass.sanitizedName}\`.
 
-Dream expects association \`${this.association.source}\` to be defiend on \`${this.throughClass.sanitizedName}\`, but \`${this.throughClass.sanitizedName}\` does not define association \`${this.association.source}\`.
+Dream expects association \`${this.association.source}\` to be defined on \`${this.throughClass.sanitizedName}\`, but \`${this.throughClass.sanitizedName}\` does not define association \`${this.association.source}\`.
 
 There are two possible fixes:
 

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

@@ -1,6 +1,7 @@
 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 DreamApp from '../../dream-app/index.js';
@@ -49,7 +50,7 @@ export const globalSchema = {
         // ${schemaConstContent}
         // `
         const schemaPath = path.join(dreamApp.projectRoot, dreamApp.paths.types, 'dream.ts');
-        await fs.writeFile(schemaPath, newSchemaFileContents);
+        await CliFileWriter.write(schemaPath, newSchemaFileContents);
     }
     globalModelNames() {
         const dreamApp = DreamApp.getOrFail();

package/dist/esm/src/index.js

@@ -1,4 +1,5 @@
 export { default as DreamBin } from './bin/index.js';
+export { CliFileWriter } from './cli/CliFileWriter.js';
 export { default as DreamCLI } from './cli/index.js';
 export { closeAllDbConnections, dreamDbConnections } from './db/DreamDbConnection.js';
 export { pgErrorType } from './db/errors.js';

package/dist/types/src/cli/CliFileWriter.d.ts

@@ -0,0 +1,9 @@
+export declare class CliFileWriter {
+    static write(filepath: string, contents: string): Promise<void>;
+    static revert(): Promise<void>;
+    static cache(filepath: string): Promise<void>;
+    private fileCache;
+    write(filepath: string, contents: string): Promise<void>;
+    revert(): Promise<void>;
+    cache(filepath: string): Promise<void>;
+}

package/dist/types/src/cli/logger/DreamCliLogger.d.ts

@@ -1,6 +1,7 @@
 import { DreamCliLoggerLogOpts } from '../../types/logger.js';
 export default class DreamCliLogger {
     log(text: string, { logPrefix, logPrefixColor, logPrefixBgColor }?: DreamCliLoggerLogOpts): void;
+    logProgress(text: string, cb: () => void | Promise<void>, { logPrefix, logPrefixColor, logPrefixBgColor }?: DreamCliLoggerLogOpts): Promise<void>;
     logStartProgress(text: string, { logPrefix, logPrefixColor, logPrefixBgColor }?: DreamCliLoggerLogOpts): void;
     logContinueProgress(text: string, { logPrefix, logPrefixColor, logPrefixBgColor }?: DreamCliLoggerLogOpts): void;
     logEndProgress(text?: string, { logPrefix, logPrefixColor, logPrefixBgColor }?: DreamCliLoggerLogOpts): void;

package/dist/types/src/decorators/Decorators.d.ts

@@ -9,12 +9,12 @@ import { ValidationType } from '../types/validation.js';
 export default class Decorators<TD extends typeof Dream, T extends Dream = InstanceType<TD>> {
     BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: NonPolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;
     BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: PolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;
-    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyOptions<T, AssociationGlobalName>): any;
-    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyThroughOptions<T, AssociationGlobalName>): any;
-    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasManyOptions<T, AssociationGlobalName>): any;
-    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneOptions<T, AssociationGlobalName>): any;
-    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneThroughOptions<T, AssociationGlobalName>): any;
-    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasOneOptions<T, AssociationGlobalName>): any;
+    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>, const ThroughAssociationName extends keyof T['schema'][T['table']]['associations']>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyOptions<T, AssociationGlobalName, ThroughAssociationName>): any;
+    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>, const ThroughAssociationName extends keyof T['schema'][T['table']]['associations']>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyThroughOptions<T, AssociationGlobalName, ThroughAssociationName>): any;
+    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>, const ThroughAssociationName extends keyof T['schema'][T['table']]['associations']>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasManyOptions<T, AssociationGlobalName, ThroughAssociationName>): any;
+    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>, const ThroughAssociationName extends keyof T['schema'][T['table']]['associations']>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneOptions<T, AssociationGlobalName, ThroughAssociationName>): any;
+    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>, const ThroughAssociationName extends keyof T['schema'][T['table']]['associations']>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneThroughOptions<T, AssociationGlobalName, ThroughAssociationName>): any;
+    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>, const ThroughAssociationName extends keyof T['schema'][T['table']]['associations']>(this: Decorators<TD>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasOneOptions<T, AssociationGlobalName, ThroughAssociationName>): any;
     /**
      * The Encrypted decorator automatically encrypts (upon setting)
      * and decrypts (upon getting) so that the encrypted value is

package/dist/types/src/decorators/field/association/HasMany.d.ts

@@ -1,6 +1,6 @@
 import Dream from '../../../Dream.js';
 import { HasManyOptions, HasManyThroughOptions, PolymorphicHasManyOptions } from '../../../types/associations/hasMany.js';
 import { GlobalModelNameTableMap } from '../../../types/dream.js';
-export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasManyOptions<BaseInstance, AssociationGlobalName>): any;
-export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasManyThroughOptions<BaseInstance, AssociationGlobalName>): any;
-export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: PolymorphicHasManyOptions<BaseInstance, AssociationGlobalName>): any;
+export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasManyOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>): any;
+export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasManyThroughOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>): any;
+export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']>(globalAssociationNameOrNames: AssociationGlobalName, opts?: PolymorphicHasManyOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>): any;

package/dist/types/src/decorators/field/association/HasOne.d.ts

@@ -1,6 +1,6 @@
 import Dream from '../../../Dream.js';
 import { HasOneOptions, HasOneThroughOptions, PolymorphicHasOneOptions } from '../../../types/associations/hasOne.js';
 import { GlobalModelNameTableMap } from '../../../types/dream.js';
-export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationName: AssociationGlobalName, opts?: HasOneOptions<BaseInstance, AssociationGlobalName>): any;
-export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasOneThroughOptions<BaseInstance, AssociationGlobalName>): any;
-export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: PolymorphicHasOneOptions<BaseInstance, AssociationGlobalName>): any;
+export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']>(globalAssociationName: AssociationGlobalName, opts?: HasOneOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>): any;
+export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasOneThroughOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>): any;
+export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']>(globalAssociationNameOrNames: AssociationGlobalName, opts?: PolymorphicHasOneOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>): any;

package/dist/types/src/errors/associations/ArrayTargetsIncompatibleWithThroughAssociation.d.ts

@@ -0,0 +1,12 @@
+import Dream from '../../Dream.js';
+import { HasManyStatement } from '../../types/associations/hasMany.js';
+import { HasOneStatement } from '../../types/associations/hasOne.js';
+export default class ArrayTargetsIncompatibleWithThroughAssociation extends Error {
+    dreamClass: typeof Dream;
+    association: HasManyStatement<any, any, any, any> | HasOneStatement<any, any, any, any>;
+    constructor({ dreamClass, association, }: {
+        dreamClass: typeof Dream;
+        association: HasOneStatement<any, any, any, any> | HasManyStatement<any, any, any, any>;
+    });
+    get message(): string;
+}

package/dist/types/src/errors/associations/CannotAssociateThroughMultiplePolymorphics.d.ts

@@ -0,0 +1,17 @@
+import Dream from '../../Dream.js';
+import { BelongsToStatement } from '../../types/associations/belongsTo.js';
+import { HasManyStatement } from '../../types/associations/hasMany.js';
+import { HasOneStatement } from '../../types/associations/hasOne.js';
+export default class CannotAssociateThroughMultiplePolymorphics extends Error {
+    dreamClass: typeof Dream;
+    association: HasManyStatement<any, any, any, any> | HasOneStatement<any, any, any, any> | BelongsToStatement<any, any, any, any>;
+    innerJoinStatements: any;
+    leftJoinStatements: any;
+    constructor({ dreamClass, association, innerJoinStatements, leftJoinStatements, }: {
+        dreamClass: typeof Dream;
+        association: HasManyStatement<any, any, any, any> | HasOneStatement<any, any, any, any> | BelongsToStatement<any, any, any, any>;
+        innerJoinStatements: any;
+        leftJoinStatements: any;
+    });
+    get message(): string;
+}

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

@@ -1,4 +1,5 @@
 export { default as DreamBin } from './bin/index.js';
+export { CliFileWriter } from './cli/CliFileWriter.js';
 export { default as DreamCLI } from './cli/index.js';
 export { closeAllDbConnections, dreamDbConnections } from './db/DreamDbConnection.js';
 export { pgErrorType } from './db/errors.js';

package/dist/types/src/types/associations/belongsTo.d.ts

@@ -6,7 +6,9 @@ export interface BelongsToStatement<BaseInstance extends Dream, DB, Schema, Tabl
     globalAssociationNameOrNames: string[];
     type: 'BelongsTo';
     as: string;
-    primaryKey: (associationInstance?: Dream) => keyof DB[TableName] & string;
+    primaryKey: (associationInstance?: Dream | undefined, opts?: {
+        associatedClassOverride?: typeof Dream | undefined;
+    }) => keyof DB[TableName] & string;
     primaryKeyValue: (associationInstance: Dream | null) => any;
     primaryKeyOverride?: (keyof DB[TableName] & string) | null;
     foreignKey: () => DreamColumnNames<BaseInstance> & string;

package/dist/types/src/types/associations/belongsTo.ts

@@ -19,7 +19,10 @@ export interface BelongsToStatement<
   globalAssociationNameOrNames: string[]
   type: 'BelongsTo'
   as: string
-  primaryKey: (associationInstance?: Dream) => keyof DB[TableName] & string
+  primaryKey: (
+    associationInstance?: Dream | undefined,
+    opts?: { associatedClassOverride?: typeof Dream | undefined }
+  ) => keyof DB[TableName] & string
   primaryKeyValue: (associationInstance: Dream | null) => any
   primaryKeyOverride?: (keyof DB[TableName] & string) | null
   foreignKey: () => DreamColumnNames<BaseInstance> & string

package/dist/types/src/types/associations/hasMany.d.ts

@@ -10,7 +10,7 @@ interface HasManyOnlyOptions<BaseInstance extends Dream, AssociationGlobalNameOr
     distinct?: TableColumnNames<BaseInstance['DB'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> | boolean;
     order?: OrderStatement<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> | OrderStatement<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>[];
 }
-export type HasManyOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
-export type PolymorphicHasManyOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
-export type HasManyThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasThroughOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
+export type HasManyOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']> = HasOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
+export type PolymorphicHasManyOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
+export type HasManyThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']> = HasThroughOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
 export {};

package/dist/types/src/types/associations/hasMany.ts

@@ -65,16 +65,20 @@ interface HasManyOnlyOptions<
 export type HasManyOptions<
   BaseInstance extends Dream,
   AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>,
-> = HasOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>
+  ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations'],
+> = HasOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName> &
+  HasManyOnlyOptions<BaseInstance, AssociationGlobalName>
 
 export type PolymorphicHasManyOptions<
   BaseInstance extends Dream,
   AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>,
-> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName> &
+  ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations'],
+> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName> &
   HasManyOnlyOptions<BaseInstance, AssociationGlobalName>
 
 export type HasManyThroughOptions<
   BaseInstance extends Dream,
   AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>,
-> = HasThroughOptions<BaseInstance, AssociationGlobalName> &
+  ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations'],
+> = HasThroughOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName> &
   HasManyOnlyOptions<BaseInstance, AssociationGlobalName>

package/dist/types/src/types/associations/hasOne.d.ts

@@ -3,6 +3,6 @@ import { AssociationTableNames } from '../db.js';
 import { GlobalModelNameTableMap } from '../dream.js';
 import { HasOptions, HasStatement, HasThroughOptions, PolymorphicHasOptions } from './shared.js';
 export type HasOneStatement<BaseInstance extends Dream, DB, Schema, ForeignTableName extends AssociationTableNames<DB, Schema> & keyof DB> = HasStatement<BaseInstance, DB, Schema, ForeignTableName, 'HasOne'>;
-export type HasOneOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasOptions<BaseInstance, AssociationGlobalName>;
-export type PolymorphicHasOneOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName>;
-export type HasOneThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasThroughOptions<BaseInstance, AssociationGlobalName>;
+export type HasOneOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']> = HasOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>;
+export type PolymorphicHasOneOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>;
+export type HasOneThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']> = HasThroughOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>;

package/dist/types/src/types/associations/hasOne.ts

@@ -13,14 +13,17 @@ export type HasOneStatement<
 export type HasOneOptions<
   BaseInstance extends Dream,
   AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>,
-> = HasOptions<BaseInstance, AssociationGlobalName>
+  ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations'],
+> = HasOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>
 
 export type PolymorphicHasOneOptions<
   BaseInstance extends Dream,
   AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>,
-> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName>
+  ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations'],
+> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>
 
 export type HasOneThroughOptions<
   BaseInstance extends Dream,
   AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>,
-> = HasThroughOptions<BaseInstance, AssociationGlobalName>
+  ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations'],
+> = HasThroughOptions<BaseInstance, AssociationGlobalName, ThroughAssociationName>

package/dist/types/src/types/associations/shared.d.ts

@@ -68,7 +68,7 @@ export interface HasStatement<BaseInstance extends Dream, DB, Schema, ForeignTab
     type: HasType;
     withoutDefaultScopes?: DefaultScopeName<BaseInstance>[];
 }
-interface HasOptionsBase<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, AssociationTableName = TableNameForGlobalModelName<BaseInstance, AssociationGlobalName & keyof GlobalModelNameTableMap<BaseInstance>>> {
+interface HasOptionsBase<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations'], ForeignTableName extends BaseInstance['schema'][BaseInstance['table']]['associations'][ThroughAssociationName]['tables'][number] = BaseInstance['schema'][BaseInstance['table']]['associations'][ThroughAssociationName]['tables'][number], AssociationTableName = TableNameForGlobalModelName<BaseInstance, AssociationGlobalName & keyof GlobalModelNameTableMap<BaseInstance>>> {
     dependent?: DependentOptions;
     foreignKey?: TableColumnNames<BaseInstance['DB'], AssociationTableName & keyof BaseInstance['DB']>;
     and?: OnStatementForAssociationDefinition<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>;
@@ -79,17 +79,17 @@ interface HasOptionsBase<BaseInstance extends Dream, AssociationGlobalName exten
     primaryKeyOverride?: DreamColumnNames<BaseInstance> | null;
     selfAnd?: SelfOnStatement<BaseInstance, BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>;
     selfAndNot?: SelfOnStatement<BaseInstance, BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>;
-    source?: string;
-    through?: keyof BaseInstance['schema'][BaseInstance['table']]['associations'];
+    source?: keyof BaseInstance['schema'][ForeignTableName]['associations'];
+    through?: ThroughAssociationName;
     withoutDefaultScopes?: DefaultScopeNameForTable<BaseInstance['schema'], AssociationTableName & keyof BaseInstance['DB']>[];
 }
 export type PolymorphicOption = 'polymorphic';
 export type ForeignKeyOption = 'foreignKey';
 type ThroughIncompatibleOptions = 'dependent' | 'primaryKeyOverride' | 'withoutDefaultScopes' | ForeignKeyOption | PolymorphicOption;
 type ThroughOnlyOptions = 'through' | 'source' | 'preloadThroughColumns';
-export type HasOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = Omit<HasOptionsBase<BaseInstance, AssociationGlobalName>, ThroughOnlyOptions | PolymorphicOption>;
-export type PolymorphicHasOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasOptionsBase<BaseInstance, AssociationGlobalName> & Required<Pick<HasOptionsBase<BaseInstance, AssociationGlobalName>, PolymorphicOption | ForeignKeyOption>>;
-export type HasThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = Omit<HasOptionsBase<BaseInstance, AssociationGlobalName>, ThroughIncompatibleOptions>;
+export type HasOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']> = Omit<HasOptionsBase<BaseInstance, AssociationGlobalName, ThroughAssociationName>, ThroughOnlyOptions | PolymorphicOption>;
+export type PolymorphicHasOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']> = HasOptionsBase<BaseInstance, AssociationGlobalName, ThroughAssociationName> & Required<Pick<HasOptionsBase<BaseInstance, AssociationGlobalName, ThroughAssociationName>, PolymorphicOption | ForeignKeyOption>>;
+export type HasThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>, ThroughAssociationName extends keyof BaseInstance['schema'][BaseInstance['table']]['associations']> = Omit<HasOptionsBase<BaseInstance, AssociationGlobalName, ThroughAssociationName>, ThroughIncompatibleOptions>;
 export interface AssociationStatementsMap {
     belongsTo: readonly BelongsToStatement<any, any, any, any>[] | BelongsToStatement<any, any, any, any>[];
     hasMany: readonly HasManyStatement<any, any, any, any>[] | HasManyStatement<any, any, any, any>[];