@rvoh/dream 2.18.0 → 2.19.0

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

@@ -205,6 +205,20 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      *
      */
     max(columnName: string): Promise<any>;
+    /**
+     * Retrieves the max value of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().maxBy('name', 'score')
+     * // Map(2) { 'primary' => 9, 'secondary' => 4 }
+     * ```
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to take the max of within each group
+     * @returns A Map from each present group value to the max of the aggregated column in that group
+     */
+    maxBy(groupColumn: string, aggregatedColumn: string): Promise<Map<any, any>>;
     /**
      * Retrieves the min value of the specified column
      * for this Query
@@ -218,6 +232,20 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * @returns the min value of the specified column for this Query
      */
     min(columnName: string): Promise<any>;
+    /**
+     * Retrieves the min value of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().minBy('name', 'score')
+     * // Map(2) { 'primary' => 1, 'secondary' => 4 }
+     * ```
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to take the min of within each group
+     * @returns A Map from each present group value to the min of the aggregated column in that group
+     */
+    minBy(groupColumn: string, aggregatedColumn: string): Promise<Map<any, any>>;
     /**
      * Retrieves the sum value of the specified column
      * for this Query
@@ -231,6 +259,20 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * @returns the sum of the values of the specified column for this Query
      */
     sum(columnName: string): Promise<any>;
+    /**
+     * Retrieves the sum of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().sumBy('name', 'score')
+     * // Map(2) { 'primary' => 10, 'secondary' => 4 }
+     * ```
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to sum within each group
+     * @returns A Map from each present group value to the sum of the aggregated column in that group
+     */
+    sumBy(groupColumn: string, aggregatedColumn: string): Promise<Map<any, any>>;
     /**
      * Retrieves the average value of the specified column
      * for this Query
@@ -244,6 +286,20 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * @returns the average of the values of the specified column for this Query
      */
     avg(columnName: string): Promise<any>;
+    /**
+     * Retrieves the average of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().avgBy('name', 'score')
+     * // Map(2) { 'primary' => 5, 'secondary' => 4 }
+     * ```
+     *
+     * @param groupColumn - the column to group by
+     * @param aggregatedColumn - the column to average within each group
+     * @returns A Map from each present group value to the average of the aggregated column in that group
+     */
+    avgBy(groupColumn: string, aggregatedColumn: string): Promise<Map<any, any>>;
     /**
      * Retrieves the number of records in the database
      *
@@ -254,6 +310,19 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * @returns The number of records in the database
      */
     count(): Promise<number>;
+    /**
+     * Retrieves the number of records in each group, keyed by the
+     * value of the provided group column.
+     *
+     * ```ts
+     * await User.query().countBy('name')
+     * // Map(2) { 'fred' => 2, 'zed' => 1 }
+     * ```
+     *
+     * @param groupColumn - the column to group by
+     * @returns A Map from each present group value to the number of records in that group
+     */
+    countBy(groupColumn: string): Promise<Map<any, number>>;
     /**
      * @internal
      *

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

@@ -157,6 +157,20 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      *
      */
     max(columnName: string): Promise<any>;
+    /**
+     * Retrieves the max value of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().maxBy('name', 'score')
+     * // Map(2) { 'primary' => 9, 'secondary' => 4 }
+     * ```
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @param aggregatedColumn - the column to take the max of within each group
+     * @returns A Map from each present group value to the max of the aggregated column in that group
+     */
+    maxBy(groupColumn: string, aggregatedColumn: string): Promise<Map<any, any>>;
     /**
      * Retrieves the min value of the specified column
      * for this Query
@@ -170,6 +184,20 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      * @returns the min value of the specified column for this Query
      */
     min(columnName: string): Promise<any>;
+    /**
+     * Retrieves the min value of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().minBy('name', 'score')
+     * // Map(2) { 'primary' => 1, 'secondary' => 4 }
+     * ```
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @param aggregatedColumn - the column to take the min of within each group
+     * @returns A Map from each present group value to the min of the aggregated column in that group
+     */
+    minBy(groupColumn: string, aggregatedColumn: string): Promise<Map<any, any>>;
     /**
      * Retrieves the sum value of the specified column
      * for this Query
@@ -183,6 +211,20 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      * @returns the sum of the values of the specified column for this Query
      */
     sum(columnName: string): Promise<any>;
+    /**
+     * Retrieves the sum of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().sumBy('name', 'score')
+     * // Map(2) { 'primary' => 10, 'secondary' => 4 }
+     * ```
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @param aggregatedColumn - the column to sum within each group
+     * @returns A Map from each present group value to the sum of the aggregated column in that group
+     */
+    sumBy(groupColumn: string, aggregatedColumn: string): Promise<Map<any, any>>;
     /**
      * Retrieves the average value of the specified column
      * for this Query
@@ -196,6 +238,20 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      * @returns the average of the values of the specified column for this Query
      */
     avg(columnName: string): Promise<any>;
+    /**
+     * Retrieves the average of the specified column within each group,
+     * keyed by the value of the provided group column.
+     *
+     * ```ts
+     * await CompositionAsset.query().avgBy('name', 'score')
+     * // Map(2) { 'primary' => 5, 'secondary' => 4 }
+     * ```
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @param aggregatedColumn - the column to average within each group
+     * @returns A Map from each present group value to the average of the aggregated column in that group
+     */
+    avgBy(groupColumn: string, aggregatedColumn: string): Promise<Map<any, any>>;
     /**
      * Retrieves the number of records in the database
      *
@@ -206,6 +262,38 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      * @returns The number of records in the database
      */
     count(): Promise<number>;
+    /**
+     * Retrieves the number of records in each group, keyed by the
+     * value of the provided group column.
+     *
+     * ```ts
+     * await User.query().countBy('name')
+     * // Map(2) { 'fred' => 2, 'zed' => 1 }
+     * ```
+     *
+     * @param groupColumn - the column to group by (base or joined-association-namespaced)
+     * @returns A Map from each present group value to the number of records in that group
+     */
+    countBy(groupColumn: string): Promise<Map<any, number>>;
+    /**
+     * @internal
+     *
+     * Shared plumbing for grouped aggregates (`countBy` and the value-aggregate
+     * siblings `minBy` / `maxBy` / `sumBy` / `avgBy`). Selects the group column
+     * alongside a single aggregate expression, groups by the group column, executes,
+     * and folds the resulting rows into a Map keyed by the group value.
+     *
+     * The group column and the aggregate are selected under stable, underscore-free
+     * aliases so they can be read back off each row without being affected by
+     * Kysely's CamelCasePlugin (which would otherwise mangle a namespaced alias),
+     * mirroring the short-alias strategy used by `pluck`.
+     *
+     * @param groupColumn - the column to GROUP BY (base or joined-association-namespaced)
+     * @param aggregateExpression - the Kysely aggregate expression to select per group (e.g. `count(pk)`)
+     * @param coerceValue - maps each raw aggregate value to the value stored in the returned Map
+     * @returns A Map from each present group value to its coerced aggregate value
+     */
+    private groupedAggregate;
     /**
      * @internal
      *
@@ -319,6 +407,48 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
     private inArrayWithNull_or_notInArrayWithoutNull_ExpressionBuilder;
     private inArrayWithoutNullExpressionBuilder;
     private notInArrayWithNullExpressionBuilder;
+    /**
+     * @internal
+     *
+     * A Dream instance (or array of Dream instances) as a where-clause value is
+     * resolved as an association of the dreamClass whose statement is being
+     * compiled, so a key namespaced to a different table (e.g.
+     * `where({ 'c.user': user })` after `innerJoin('composition as c')`) would
+     * silently resolve the association against the wrong class, emitting invalid
+     * SQL or SQL that filters the wrong table. Such keys are already rejected at
+     * the type level; this guard rejects them at runtime. Un-namespaced keys and
+     * keys namespaced to the alias the statement applies to are unaffected, as
+     * are callers that do not declare an expected alias.
+     */
+    private validateAssociationFilterAlias;
+    /**
+     * @internal
+     *
+     * An array under an association name can only be an array of Dream instances
+     * (association names are not columns). The every-element check simply avoids
+     * changing the handling of invalid runtime input (e.g. an array of ids under
+     * an association name), which the type system already rejects.
+     */
+    private isAssociationInstanceArray;
+    /**
+     * @internal
+     *
+     * Expands an array of Dream instances under a BelongsTo association name into
+     * foreign key filtering:
+     * - non-polymorphic: `foreignKey IN (...)`
+     * - polymorphic: instances are grouped by their reference type (STI children
+     *   collapse into their base class), each group becoming
+     *   `(foreignKey IN (...) AND foreignKeyTypeField = 'TheType')`, with multiple
+     *   groups ORed together
+     * - empty array: matches nothing (FALSE); when the caller negates, NOT(FALSE)
+     *   matches everything, mirroring empty `in`/`not in` array semantics
+     *
+     * When `negate` is set, IS NOT NULL conditions are included so that the
+     * caller's negation also matches records in which the foreign key (or type
+     * field) is null, consistent with negation of single Dream instances and of
+     * `in` arrays.
+     */
+    private associationInstanceArrayToExpressionWrapper;
     private dreamWhereStatementToExpressionBuilderParts;
     private normalizedWhereValue;
     private recursivelyJoin;
@@ -466,26 +596,54 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      *   public b
      * ```
      *
+     * Options declared on a through association (`and`/`andAny`/`andNot`/`selfAnd`/
+     * `selfAndNot`/`order`/`distinct`) are applied at the join of the table where the
+     * through association's target model materializes. When a source is itself a
+     * through association, that join is only reached after bridging further through
+     * associations, so each through association is pushed onto the
+     * `previousThroughAssociations` stack (along with the alias `selfAnd`/`selfAndNot`
+     * clauses reference) before the terminal `applyOneJoin` call, and the stack is
+     * threaded through every recursion until `addAssociationJoinStatementToQuery`
+     * reaches a concrete (non-through) association, where every stacked entry is
+     * applied to that join.
+     *
      * Then `MyModel.leftJoinPreload('myB')` is processed as follows:
      * - `applyOneJoin` is called with the `myB` association
      *   - `joinsBridgeThroughAssociations` is called with the `myB` association
      *     - `joinsBridgeThroughAssociations` is called with the `myA` association
      *       - `addAssociationJoinStatementToQuery` is called with the `otherModel` association
-     *       - `applyOneJoin` is called with the `a` association from OtherModel
-     *         - `joinsBridgeThroughAssociations` is called with the `a` association from OtherModel
-     *           // throw ThroughAssociationConditionsIncompatibleWithThroughAssociationSource if
-     *           // myA in MyModel defines conditions, distinct, or order
+     *       - `applyOneJoin` is called with the `a` association from OtherModel, with `myA` pushed
+     *         onto the previousThroughAssociations stack
+     *         - `joinsBridgeThroughAssociations` is called with the `a` association from OtherModel,
+     *           inheriting the stack
      *           - `addAssociationJoinStatementToQuery` is called with the `aToOtherModelJoinModel` association
-     *           - `applyOneJoin` is called with the `a` association from AToOtherModelJoinModel with conditions (if present) on `a` defined on OtherModel
-     *             - `addAssociationJoinStatementToQuery` is called with the `myA` association
-     *     - `applyOneJoin` is called with the `b` association from A with conditions (if present) from `myB` defined on MyModel
-     *       - `addAssociationJoinStatementToQuery` is called with the `myB` association
+     *           - `applyOneJoin` is called with the `a` association from AToOtherModelJoinModel, with the
+     *             `a` association from OtherModel pushed onto the stack
+     *             - `addAssociationJoinStatementToQuery` is called with the `a` association from
+     *               AToOtherModelJoinModel, applying the options (if present) of every stacked through
+     *               association (`myA` defined on MyModel, `a` defined on OtherModel) to the `through_as` join
+     *     - `applyOneJoin` is called with the `b` association from A, with `myB` pushed onto the stack
+     *       - `addAssociationJoinStatementToQuery` is called with the `b` association from A, applying
+     *         the options (if present) of `myB` defined on MyModel to the `through_bs` join
      */
     private joinsBridgeThroughAssociations;
     private applyOneJoin;
     private addAssociationJoinStatementToQuery;
     private applyOrderStatementForAssociation;
     private distinctColumnNameForAssociation;
+    /**
+     * Applies the and-family clauses (`and`/`andAny`/`andNot`/`selfAnd`/`selfAndNot`)
+     * of every pending through association to the terminal concrete join of a
+     * through association chain.
+     *
+     * The first entry in the stack is the association the developer named in the
+     * join/preload/associationQuery statement, so it is the association the
+     * developer-supplied joinAndStatement corresponds to (used to satisfy
+     * `DreamConst.required` clauses); `DreamConst.required` on any other stacked
+     * through association cannot be satisfied and will throw
+     * `MissingRequiredAssociationAndClause`.
+     */
+    private applyPreviousThroughAssociationAndStatementsToJoinStatement;
     private applyAssociationAndStatementsToJoinStatement;
     private throwUnlessAllRequiredWhereClausesProvided;
     private conditionallyApplyDefaultScopesDependentOnAssociation;

package/dist/types/src/errors/CannotNamespaceAssociationFilterToAnotherTable.d.ts

@@ -0,0 +1,8 @@
+import Dream from '../Dream.js';
+export default class CannotNamespaceAssociationFilterToAnotherTable extends Error {
+    private dreamClass;
+    private key;
+    private expectedAlias;
+    constructor(dreamClass: typeof Dream, key: string, expectedAlias: string);
+    get message(): string;
+}

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

@@ -34,8 +34,11 @@ type JoinedAssociationColumnNames<JoinedAssociations extends Readonly<JoinedAsso
 type Whereable<R> = {
     [K in keyof Selectable<R>]?: Selectable<R>[K] | Selectable<R>[K][];
 };
+type WhereableAssociatedModelParam<I extends Dream> = {
+    [K in keyof AssociatedModelParam<I>]: AssociatedModelParam<I>[K] | NonNullable<AssociatedModelParam<I>[K]>[];
+};
 export type WhereStatement<I extends Dream> = InternalWhereStatement<I, I['DB'], I['schema'], I['table']>;
-export type InternalWhereStatement<I extends Dream, DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = Partial<MergeUnionOfRecordTypes<Whereable<DB[TableName]> | DreamSelectable<DB, Schema, TableName> | AssociatedModelParam<I>>>;
+export type InternalWhereStatement<I extends Dream, DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = Partial<MergeUnionOfRecordTypes<Whereable<DB[TableName]> | DreamSelectable<DB, Schema, TableName> | WhereableAssociatedModelParam<I>>>;
 export type OnStatementForAssociation<I extends Dream, DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation, OnStatement extends InternalWhereStatement<I, DB, Schema, TableName> = InternalWhereStatement<I, DB, Schema, TableName>> = RequiredOnClauseKeysForThisAssociation extends null ? InternalWhereStatement<I, DB, Schema, TableName> : RequiredOnClauseKeysForThisAssociation extends string[] ? Required<Pick<OnStatement, RequiredOnClauseKeysForThisAssociation[number] & keyof OnStatement>> & Partial<Omit<OnStatement, RequiredOnClauseKeysForThisAssociation[number] & keyof OnStatement>> : never;
 export type OnStatementForSpecificColumns<I extends Dream, DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB, Columns extends string[], OnStatement extends InternalWhereStatement<I, DB, Schema, TableName> = InternalWhereStatement<I, DB, Schema, TableName>> = Pick<OnStatement, Columns[number] & keyof OnStatement>;
 type OnStatementForAssociationDefinition<DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> = Partial<MergeUnionOfRecordTypes<Partial<Selectable<DB[TableName]>> | Partial<{

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

@@ -51,6 +51,23 @@ export type PassthroughOnClauseKeys<Schema, TableName, AssociationName, Associat
  * must be forbidden at compile time for the hydrating load variants.
  */
 export type IsNonOptionalBelongsToAssociation<Schema, TableName, AssociationName, Associations = TableName extends null ? null : TableName extends keyof Schema & string ? Schema[TableName]['associations' & keyof Schema[TableName]] : null, Association = Associations extends null ? null : AssociationName extends keyof Associations ? Associations[AssociationName] : null> = Association extends null ? false : Association['type' & keyof Association] extends 'BelongsTo' ? Association['optional' & keyof Association] extends false ? true : false : false;
+/**
+ * Resolves to `true` when the named association on the given table is a
+ * polymorphic BelongsTo. Joining a polymorphic BelongsTo raises
+ * CannotJoinPolymorphicBelongsToError at runtime, so the variadic join types
+ * (innerJoin / leftJoin / leftJoinPreload / leftJoinLoad) reject these
+ * association names at compile time.
+ */
+export type IsPolymorphicBelongsToAssociation<Schema, TableName, AssociationName, Associations = TableName extends null ? null : TableName extends keyof Schema & string ? Schema[TableName]['associations' & keyof Schema[TableName]] : null, Association = Associations extends null ? null : AssociationName extends keyof Associations ? Associations[AssociationName] : null> = Association extends null ? false : Association['type' & keyof Association] extends 'BelongsTo' ? Association['foreignKeyTypeColumn' & keyof Association] extends string ? true : false : false;
+/**
+ * Union of the association names on the given table that are polymorphic
+ * BelongsTo associations. Used by the variadic join types to exclude these
+ * names from the allowed argument values, since joining a polymorphic
+ * BelongsTo raises CannotJoinPolymorphicBelongsToError at runtime.
+ */
+export type PolymorphicBelongsToAssociationNames<Schema, TableName extends keyof Schema, AssociationMetadata = AssociationMetadataForTable<Schema, TableName>> = IsAny<AssociationMetadata> extends true ? never : {
+    [K in keyof AssociationMetadata]: AssociationMetadata[K]['type' & keyof AssociationMetadata[K]] extends 'BelongsTo' ? AssociationMetadata[K]['foreignKeyTypeColumn' & keyof AssociationMetadata[K]] extends string ? K : never : never;
+}[keyof AssociationMetadata];
 export type DreamAssociationNames<DreamInstance extends Dream, SchemaAssociations = DreamAssociationMetadata<DreamInstance>> = keyof SchemaAssociations;
 export type DreamBelongsToAssociationNames<DreamInstance extends Dream> = keyof DreamBelongsToAssociationMetadata<DreamInstance>;
 export type DreamHasOneAssociationNames<DreamInstance extends Dream> = keyof DreamHasOneAssociationMetadata<DreamInstance>;

package/dist/types/src/types/{associations → types/associations}/shared.ts

@@ -221,6 +221,15 @@ type Whereable<R> = {
   [K in keyof Selectable<R>]?: Selectable<R>[K] | Selectable<R>[K][]
 }
 
+// For filtering by BelongsTo model instance(s) in a where/and statement, e.g.
+// `await Room.where({ place: [place1, place2] }).all()`. Unlike
+// `AssociatedModelParam` (the create/update param type, where an array of
+// instances would be meaningless), each association also accepts an array
+// of associated model instances.
+type WhereableAssociatedModelParam<I extends Dream> = {
+  [K in keyof AssociatedModelParam<I>]: AssociatedModelParam<I>[K] | NonNullable<AssociatedModelParam<I>[K]>[]
+}
+
 export type WhereStatement<I extends Dream> = InternalWhereStatement<I, I['DB'], I['schema'], I['table']>
 
 export type InternalWhereStatement<
@@ -230,7 +239,7 @@ export type InternalWhereStatement<
   TableName extends AssociationTableNames<DB, Schema> & keyof DB,
 > = Partial<
   MergeUnionOfRecordTypes<
-    Whereable<DB[TableName]> | DreamSelectable<DB, Schema, TableName> | AssociatedModelParam<I>
+    Whereable<DB[TableName]> | DreamSelectable<DB, Schema, TableName> | WhereableAssociatedModelParam<I>
   >
 >
 

package/dist/types/src/types/{dream.ts → types/dream.ts}

@@ -254,6 +254,59 @@ export type IsNonOptionalBelongsToAssociation<
       : false
     : false
 
+/**
+ * Resolves to `true` when the named association on the given table is a
+ * polymorphic BelongsTo. Joining a polymorphic BelongsTo raises
+ * CannotJoinPolymorphicBelongsToError at runtime, so the variadic join types
+ * (innerJoin / leftJoin / leftJoinPreload / leftJoinLoad) reject these
+ * association names at compile time.
+ */
+export type IsPolymorphicBelongsToAssociation<
+  Schema,
+  TableName,
+  AssociationName,
+  Associations = TableName extends null
+    ? null
+    : TableName extends keyof Schema & string
+      ? Schema[TableName]['associations' & keyof Schema[TableName]]
+      : null,
+  Association = Associations extends null
+    ? null
+    : AssociationName extends keyof Associations
+      ? Associations[AssociationName]
+      : null,
+> = Association extends null
+  ? false
+  : Association['type' & keyof Association] extends 'BelongsTo'
+    ? Association['foreignKeyTypeColumn' & keyof Association] extends string
+      ? true
+      : false
+    : false
+
+/**
+ * Union of the association names on the given table that are polymorphic
+ * BelongsTo associations. Used by the variadic join types to exclude these
+ * names from the allowed argument values, since joining a polymorphic
+ * BelongsTo raises CannotJoinPolymorphicBelongsToError at runtime.
+ */
+export type PolymorphicBelongsToAssociationNames<
+  Schema,
+  TableName extends keyof Schema,
+  AssociationMetadata = AssociationMetadataForTable<Schema, TableName>,
+> =
+  // when the schema is untyped (`any`), resolve to `never` so nothing is
+  // excluded from the allowed association names
+  IsAny<AssociationMetadata> extends true
+    ? never
+    : {
+        [K in keyof AssociationMetadata]: AssociationMetadata[K]['type' &
+          keyof AssociationMetadata[K]] extends 'BelongsTo'
+          ? AssociationMetadata[K]['foreignKeyTypeColumn' & keyof AssociationMetadata[K]] extends string
+            ? K
+            : never
+          : never
+      }[keyof AssociationMetadata]
+
 export type DreamAssociationNames<
   DreamInstance extends Dream,
   SchemaAssociations = DreamAssociationMetadata<DreamInstance>,