@rvoh/dream 2.35.0 → 2.36.1

package/dist/types/src/types/types/openapi.ts

@@ -32,17 +32,17 @@ export type OpenapiSchemaBase =
   | OpenapiSchemaNull
   | OpenapiSchemaExpressionRef
 
-export type OpenapiSchemaShorthandExpressionAnyOf = {
+export type OpenapiSchemaShorthandExpressionAnyOf = OpenapiSchemaCombinatorFields<{
   anyOf: OpenapiSchemaBodyShorthand[]
-}
+}>
 
-export type OpenapiSchemaShorthandExpressionOneOf = {
+export type OpenapiSchemaShorthandExpressionOneOf = OpenapiSchemaCombinatorFields<{
   oneOf: OpenapiSchemaBodyShorthand[]
-}
+}>
 
-export type OpenapiSchemaShorthandExpressionAllOf = {
+export type OpenapiSchemaShorthandExpressionAllOf = OpenapiSchemaCombinatorFields<{
   allOf: OpenapiSchemaBodyShorthand[]
-}
+}>
 
 export type OpenapiSchemaShorthandExpressionSerializerRef = {
   $serializer: DreamModelSerializerType | SimpleObjectSerializerType
@@ -66,21 +66,40 @@ export type OpenapiSchemaExpressionRefSchemaShorthand = {
   $schema: string
 }
 
-export type OpenapiSchemaExpressionAllOf = {
+export type OpenapiSchemaExpressionAllOf = OpenapiSchemaCombinatorFields<{
   allOf: OpenapiSchemaBody[]
-}
+}>
 
-export type OpenapiSchemaExpressionAnyOf = {
+export type OpenapiSchemaExpressionAnyOf = OpenapiSchemaCombinatorFields<{
   anyOf: OpenapiSchemaBody[]
-}
+}>
 
-export type OpenapiSchemaExpressionOneOf = {
+export type OpenapiSchemaExpressionOneOf = OpenapiSchemaCombinatorFields<{
   oneOf: OpenapiSchemaBody[]
-}
+}>
 
+/**
+ * The fields of a schema that declares a `type`. `anyOf` and `oneOf` are not
+ * among them: they apply to every value, `null` included, so a nullable `type`
+ * beside one cannot admit `null`. A schema that may be null lists a
+ * `{ type: 'null' }` branch in its `anyOf` or `oneOf` instead.
+ */
 export type OpenapiSchemaCommonFields<T> = T & {
   description?: string
   summary?: string
+  anyOf?: never
+  oneOf?: never
+}
+
+/**
+ * The fields of a schema that is an `allOf`, `anyOf` or `oneOf`: the
+ * combinator and the fields that describe it, but no `type` (see
+ * `OpenapiSchemaCommonFields`).
+ */
+export type OpenapiSchemaCombinatorFields<T> = T & {
+  description?: string
+  summary?: string
+  type?: never
 }
 
 export type OpenapiSchemaString = OpenapiSchemaCommonFields<{
@@ -108,15 +127,13 @@ export type OpenapiSchemaNumber = OpenapiSchemaCommonFields<{
 
 export type OpenapiSchemaNull = {
   type: 'null'
+  anyOf?: never
+  oneOf?: never
 }
 
 export type OpenapiNumberFormats = 'decimal' | 'double'
 
-export type OpenapiSchemaObject =
-  | OpenapiSchemaObjectBase
-  | OpenapiSchemaObjectOneOf
-  | OpenapiSchemaObjectAnyOf
-  | OpenapiSchemaObjectAllOf
+export type OpenapiSchemaObject = OpenapiSchemaObjectBase | OpenapiSchemaObjectAllOf
 
 export type OpenapiSchemaObjectBase = CommonOpenapiSchemaObjectFields<{
   minProperties?: number
@@ -132,24 +149,23 @@ export type OpenapiSchemaObjectBase = CommonOpenapiSchemaObjectFields<{
     | OpenapiSchemaExpressionAnyOf
     | OpenapiSchemaExpressionAllOf
     | false
+  allOf?: never
 }>
 
-export type OpenapiSchemaObjectOneOf = CommonOpenapiSchemaObjectFields<{
-  oneOf?: OpenapiSchemaBody[]
-}>
-
-export type OpenapiSchemaObjectAnyOf = CommonOpenapiSchemaObjectFields<{
-  anyOf?: OpenapiSchemaBody[]
-}>
-
-export type OpenapiSchemaObjectAllOf = CommonOpenapiSchemaObjectFields<{
+/**
+ * An object schema that is also an `allOf`. Its `type` cannot be nullable:
+ * `allOf` applies to every value, so `null` would have to match each of its
+ * object members. A schema that may be null is an `anyOf` or `oneOf` with a
+ * `{ type: 'null' }` branch.
+ */
+export type OpenapiSchemaObjectAllOf = OpenapiSchemaCommonFields<{
+  type: 'object'
+  required?: string[]
   allOf?: OpenapiSchemaBody[]
 }>
 
 export type OpenapiSchemaObjectShorthand =
   | OpenapiSchemaObjectBaseShorthand
-  | OpenapiSchemaObjectOneOfShorthand
-  | OpenapiSchemaObjectAnyOfShorthand
   | OpenapiSchemaObjectAllOfShorthand
 
 export type OpenapiSchemaObjectBaseShorthand = CommonOpenapiSchemaObjectFields<{
@@ -171,17 +187,15 @@ export type OpenapiSchemaObjectBaseShorthand = CommonOpenapiSchemaObjectFields<{
     | OpenapiSchemaShorthandExpressionSerializerRef
     | OpenapiSchemaShorthandExpressionSerializableRef
     | false
+  allOf?: never
 }>
 
-export type OpenapiSchemaObjectOneOfShorthand = CommonOpenapiSchemaObjectFields<{
-  oneOf?: OpenapiSchemaBodyShorthand[]
-}>
-
-export type OpenapiSchemaObjectAnyOfShorthand = CommonOpenapiSchemaObjectFields<{
-  anyOf?: OpenapiSchemaBodyShorthand[]
-}>
-
-export type OpenapiSchemaObjectAllOfShorthand = CommonOpenapiSchemaObjectFields<{
+/**
+ * The shorthand form of `OpenapiSchemaObjectAllOf`.
+ */
+export type OpenapiSchemaObjectAllOfShorthand = OpenapiSchemaCommonFields<{
+  type: 'object'
+  required?: string[]
   allOf?: OpenapiSchemaBodyShorthand[]
 }>
 

package/dist/types/src/types/types/serializer.ts

@@ -2,7 +2,13 @@ import Dream from '../Dream.js'
 import { RoundingPrecision } from '../helpers/round.js'
 import DreamSerializerBuilder from '../serializer/builders/DreamSerializerBuilder.js'
 import ObjectSerializerBuilder from '../serializer/builders/ObjectSerializerBuilder.js'
-import { DreamSerializable, DreamSerializableArray, ViewModelClass } from './dream.js'
+import {
+  DreamSerializable,
+  DreamSerializableArray,
+  DreamVirtualColumns,
+  NonJsonDreamColumnNames,
+  ViewModelClass,
+} from './dream.js'
 import { OpenapiDescription, OpenapiSchemaBodyShorthand, OpenapiShorthandPrimitiveTypes } from './openapi.js'
 
 export type SerializerCasing = 'camel' | 'snake'
@@ -32,7 +38,11 @@ export interface InternalAnyTypedSerializerCustomAttribute {
   type: 'customAttribute'
   name: string
   fn: (x?: any, y?: any) => any
-  options: Omit<NonAutomaticSerializerAttributeOptions, 'as'> & { flatten?: boolean }
+  options: {
+    openapi: CustomAttributeOpenapi
+    required?: false
+    flatten?: boolean
+  }
 }
 
 export interface InternalAnyRendersOneOrManyOpts {
@@ -143,6 +153,56 @@ export type NonAutomaticSerializerAttributeOptionsWithPossibleDecimalRenderOptio
     precision?: RoundingPrecision
   }
 
+/**
+ * The options argument of `DreamSerializer#delegatedAttribute`. A Dream model's non-json
+ * column infers its OpenAPI shape, so its `openapi` takes only a description and the
+ * argument may be left out. A json/jsonb column or a non-Dream target has no shape to
+ * infer, so the argument is required and its `openapi` takes a full shape.
+ */
+export type DelegatedAttributeOptionsArgs<AssociatedModelType, TargetAttributeName> =
+  DelegatedAttributeOptions<AssociatedModelType, TargetAttributeName> extends infer Options
+    ? Partial<Options> extends Options
+      ? [options?: Options]
+      : [options: Options]
+    : never
+
+type DelegatedAttributeOptions<AssociatedModelType, TargetAttributeName> = AssociatedModelType extends Dream
+  ? TargetAttributeName extends NonJsonDreamColumnNames<AssociatedModelType> &
+      keyof AssociatedModelType &
+      'type'
+    ? AutomaticSerializerAttributeOptionsForType & {
+        optional?: boolean
+        required?: false
+      }
+    : TargetAttributeName extends DreamVirtualColumns<AssociatedModelType>[number]
+      ? SerializerAttributeOptionsForVirtualColumn & { optional?: boolean }
+      : TargetAttributeName extends NonJsonDreamColumnNames<AssociatedModelType> &
+            keyof AssociatedModelType &
+            string
+        ? AutomaticSerializerAttributeOptions & { optional?: boolean }
+        : NonAutomaticSerializerAttributeOptionsWithPossibleDecimalRenderOption & {
+            optional?: boolean
+          }
+  : NonAutomaticSerializerAttributeOptionsWithPossibleDecimalRenderOption & { optional?: boolean }
+
+type CustomAttributeOpenapi = OpenapiSchemaBodyShorthand | OpenapiShorthandPrimitiveTypes
+
+/**
+ * The options of `customAttribute`. The callback's return value renders as is, so there is
+ * no `as`, `default` or `precision`. With `flatten: true`, `openapi` may be anything but a
+ * serializer ref with `many: true`: flattening spreads one object's properties into the
+ * parent, and a list has none to spread.
+ */
+export type CustomAttributeOptions =
+  | { openapi: CustomAttributeOpenapi; required?: false; flatten?: false }
+  | { openapi: OpenapiForFlattening<CustomAttributeOpenapi>; required?: false; flatten: true }
+
+type OpenapiForFlattening<Openapi> = Openapi extends unknown
+  ? 'many' extends keyof Openapi
+    ? Omit<Openapi, 'many'> & { many?: false }
+    : Openapi
+  : never
+
 export type DreamModelSerializerType = (data: any, passthroughData?: any) => DreamSerializerBuilder<any, any>
 
 export type SimpleObjectSerializerType = (

package/dist/types/src/types/types/variadic.ts

@@ -27,6 +27,46 @@ type IS_ASSOCIATION_NAME = 'association_name'
 type IS_NOT_ASSOCIATION_NAME = 'not_association_name'
 type RecursionTypes = 'load' | 'leftJoinLoad' | 'join'
 
+/**
+ * The keys of a condition object that a chain argument does not
+ * accept: anything other than `and`, `andNot` and `andAny`. Association
+ * names, arrays and non-objects yield `never`. Index-signature keys
+ * (`string`, `number`) yield `never` too, since they name no key the
+ * checker can reject; the runtime check covers those values.
+ */
+type StrayConditionKeys<T> = T extends string | readonly unknown[]
+  ? never
+  : T extends object
+    ? StrayConditionKey<keyof T>
+    : never
+type StrayConditionKey<K> = K extends 'and' | 'andNot' | 'andAny'
+  ? never
+  : string extends K
+    ? never
+    : number extends K
+      ? never
+      : K
+
+declare const onlyConditionKeys: unique symbol
+
+/**
+ * The join variants infer their final argument as a `const LastArg` type
+ * parameter (it drives the joined-associations return type), so the
+ * argument is checked against its own inferred type and an extra key on
+ * an object literal escapes the excess-property check. Given the inferred
+ * `LastArg`, this narrows the object members of `Allowed` to a shape no
+ * value carries whenever `LastArg` has a key other than `and`, `andNot`
+ * or `andAny`: the inferred type then fails its constraint, TypeScript
+ * falls back to the constraint, and an object literal gets the ordinary
+ * excess-property error at the stray key.
+ */
+type WithoutStrayConditionKeys<LastArg, Allowed> = [StrayConditionKeys<LastArg>] extends [never]
+  ? Allowed
+  :
+      | Exclude<Allowed, object>
+      | Extract<Allowed, readonly unknown[]>
+      | (Exclude<Extract<Allowed, object>, readonly unknown[]> & { [onlyConditionKeys]: never })
+
 /**
  * Given a union of table names and an association name, returns the
  * specific table(s) from the union that have that association defined.
@@ -82,6 +122,9 @@ export type VariadicLeftJoinLoadArgs<
   Schema,
   ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB,
   ConcreteArgs extends readonly unknown[],
+  // the final argument, when the caller infers it as a type parameter
+  // (see WithoutStrayConditionKeys)
+  LastArg = never,
   //
   SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]],
   // joining a polymorphic BelongsTo raises CannotJoinPolymorphicBelongsToError
@@ -93,23 +136,26 @@ export type VariadicLeftJoinLoadArgs<
         AliasedSchemaAssociation<Schema, ConcreteTableName>,
         `${PolymorphicBelongsToNames & string} as ${string}`
       >,
-> = VariadicCheckThenRecurse<
-  I,
-  DB,
-  Schema,
-  ConcreteTableName,
-  ConcreteArgs,
-  'leftJoinLoad',
-  // Dream configures Kysely to use camel case in Typescript land and
-  // convert to snake case in SQL; however, Dream reference snake-cased table names.
-  // Without camelizing, the table name of the starting model could conflict with the
-  // snake-cased version of an association name. By camelizing the table that goes
-  // into the UsedNamespaces, we prevent this from happeing at the type level.
-  Camelized<ConcreteTableName>,
-  0,
-  null,
-  never,
-  AllowedNextArgValues | Readonly<AllowedNextArgValues[]>
+> = WithoutStrayConditionKeys<
+  LastArg,
+  VariadicCheckThenRecurse<
+    I,
+    DB,
+    Schema,
+    ConcreteTableName,
+    ConcreteArgs,
+    'leftJoinLoad',
+    // Dream configures Kysely to use camel case in Typescript land and
+    // convert to snake case in SQL; however, Dream reference snake-cased table names.
+    // Without camelizing, the table name of the starting model could conflict with the
+    // snake-cased version of an association name. By camelizing the table that goes
+    // into the UsedNamespaces, we prevent this from happeing at the type level.
+    Camelized<ConcreteTableName>,
+    0,
+    null,
+    never,
+    AllowedNextArgValues | Readonly<AllowedNextArgValues[]>
+  >
 >
 ///////////////////////////////
 // end:VARIADIC LEFT JOIN LOAD
@@ -123,6 +169,9 @@ export type VariadicJoinsArgs<
   Schema,
   ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB,
   ConcreteArgs extends readonly unknown[],
+  // the final argument, when the caller infers it as a type parameter
+  // (see WithoutStrayConditionKeys)
+  LastArg = never,
   //
   SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]],
   // joining a polymorphic BelongsTo raises CannotJoinPolymorphicBelongsToError
@@ -134,23 +183,26 @@ export type VariadicJoinsArgs<
         AliasedSchemaAssociation<Schema, ConcreteTableName>,
         `${PolymorphicBelongsToNames & string} as ${string}`
       >,
-> = VariadicCheckThenRecurse<
-  I,
-  DB,
-  Schema,
-  ConcreteTableName,
-  ConcreteArgs,
-  'join',
-  // Dream configures Kysely to use camel case in Typescript land and
-  // convert to snake case in SQL; however, Dream reference snake-cased table names.
-  // Without camelizing, the table name of the starting model could conflict with the
-  // snake-cased version of an association name. By camelizing the table that goes
-  // into the UsedNamespaces, we prevent this from happeing at the type level.
-  Camelized<ConcreteTableName>,
-  0,
-  null,
-  never,
-  AllowedNextArgValues
+> = WithoutStrayConditionKeys<
+  LastArg,
+  VariadicCheckThenRecurse<
+    I,
+    DB,
+    Schema,
+    ConcreteTableName,
+    ConcreteArgs,
+    'join',
+    // Dream configures Kysely to use camel case in Typescript land and
+    // convert to snake case in SQL; however, Dream reference snake-cased table names.
+    // Without camelizing, the table name of the starting model could conflict with the
+    // snake-cased version of an association name. By camelizing the table that goes
+    // into the UsedNamespaces, we prevent this from happeing at the type level.
+    Camelized<ConcreteTableName>,
+    0,
+    null,
+    never,
+    AllowedNextArgValues
+  >
 >
 ///////////////////////////////
 // end: VARIADIC JOINS
@@ -222,15 +274,19 @@ type VariadicCheckThenRecurse<
               ConcreteTableName,
               RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>
             >
-          ? RecursionType extends 'join'
-            ? VALID
-            : IsNonOptionalBelongsToAssociation<
-                  Schema,
-                  PreviousConcreteTableName,
-                  ConcreteAssociationName
-                > extends true
-              ? INVALID_CONSTRAINT_ON_REQUIRED_BELONGS_TO
-              : VALID
+          ? // `extends` is structural, so it accepts extra keys alongside a
+            // valid one; a condition accepts only and/andNot/andAny
+            [StrayConditionKeys<ConcreteArgs[0]>] extends [never]
+            ? RecursionType extends 'join'
+              ? VALID
+              : IsNonOptionalBelongsToAssociation<
+                    Schema,
+                    PreviousConcreteTableName,
+                    ConcreteAssociationName
+                  > extends true
+                ? INVALID_CONSTRAINT_ON_REQUIRED_BELONGS_TO
+                : VALID
+            : INVALID
           : INVALID,
 > = NthArgument extends INVALID_NON_TERMINAL_ARRAY
   ? `an array of association names is only allowed as the final argument (argument ${Inc<Depth>})`

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

@@ -13,6 +13,30 @@ type IS_ASSOCIATION_ALIAS = 'association_alias';
 type IS_ASSOCIATION_NAME = 'association_name';
 type IS_NOT_ASSOCIATION_NAME = 'not_association_name';
 type RecursionTypes = 'load' | 'leftJoinLoad' | 'join';
+/**
+ * The keys of a condition object that a chain argument does not
+ * accept: anything other than `and`, `andNot` and `andAny`. Association
+ * names, arrays and non-objects yield `never`. Index-signature keys
+ * (`string`, `number`) yield `never` too, since they name no key the
+ * checker can reject; the runtime check covers those values.
+ */
+type StrayConditionKeys<T> = T extends string | readonly unknown[] ? never : T extends object ? StrayConditionKey<keyof T> : never;
+type StrayConditionKey<K> = K extends 'and' | 'andNot' | 'andAny' ? never : string extends K ? never : number extends K ? never : K;
+declare const onlyConditionKeys: unique symbol;
+/**
+ * The join variants infer their final argument as a `const LastArg` type
+ * parameter (it drives the joined-associations return type), so the
+ * argument is checked against its own inferred type and an extra key on
+ * an object literal escapes the excess-property check. Given the inferred
+ * `LastArg`, this narrows the object members of `Allowed` to a shape no
+ * value carries whenever `LastArg` has a key other than `and`, `andNot`
+ * or `andAny`: the inferred type then fails its constraint, TypeScript
+ * falls back to the constraint, and an object literal gets the ordinary
+ * excess-property error at the stray key.
+ */
+type WithoutStrayConditionKeys<LastArg, Allowed> = [StrayConditionKeys<LastArg>] extends [never] ? Allowed : Exclude<Allowed, object> | Extract<Allowed, readonly unknown[]> | (Exclude<Extract<Allowed, object>, readonly unknown[]> & {
+    [onlyConditionKeys]: never;
+});
 /**
  * Given a union of table names and an association name, returns the
  * specific table(s) from the union that have that association defined.
@@ -21,9 +45,11 @@ type RecursionTypes = 'load' | 'leftJoinLoad' | 'join';
  */
 type TableContainingAssociationInUnion<Schema, TableNamesUnion, AssociationName> = TableNamesUnion extends keyof Schema ? AssociationName extends keyof Schema[TableNamesUnion]['associations' & keyof Schema[TableNamesUnion]] ? TableNamesUnion : never : never;
 export type VariadicLoadArgs<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], AllowedNextArgValues = (keyof SchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName>> = VariadicCheckThenRecurse<I, DB, Schema, ConcreteTableName, ConcreteArgs, 'load', never, 0, null, never, AllowedNextArgValues | Readonly<AllowedNextArgValues[]>>;
-export type VariadicLeftJoinLoadArgs<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], PolymorphicBelongsToNames = PolymorphicBelongsToAssociationNames<Schema, ConcreteTableName>, AllowedNextArgValues = Exclude<keyof SchemaAssociations & string, PolymorphicBelongsToNames> | Exclude<AliasedSchemaAssociation<Schema, ConcreteTableName>, `${PolymorphicBelongsToNames & string} as ${string}`>> = VariadicCheckThenRecurse<I, DB, Schema, ConcreteTableName, ConcreteArgs, 'leftJoinLoad', Camelized<ConcreteTableName>, 0, null, never, AllowedNextArgValues | Readonly<AllowedNextArgValues[]>>;
-export type VariadicJoinsArgs<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], PolymorphicBelongsToNames = PolymorphicBelongsToAssociationNames<Schema, ConcreteTableName>, AllowedNextArgValues = Exclude<keyof SchemaAssociations & string, PolymorphicBelongsToNames> | Exclude<AliasedSchemaAssociation<Schema, ConcreteTableName>, `${PolymorphicBelongsToNames & string} as ${string}`>> = VariadicCheckThenRecurse<I, DB, Schema, ConcreteTableName, ConcreteArgs, 'join', Camelized<ConcreteTableName>, 0, null, never, AllowedNextArgValues>;
-type VariadicCheckThenRecurse<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], RecursionType extends RecursionTypes, UsedNamespaces, Depth extends number, PreviousConcreteTableName, ConcreteAssociationName, AssociationNamesOrOnClause, LastDream extends Dream = I, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], AllowedNamesForNthArg = PreviousConcreteTableName extends keyof Schema ? AssociationNamesForAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> : keyof SchemaAssociations & string, UnaliasedNthArg = ConcreteArgs[0] extends `${infer AssociationName extends string} as ${string}` ? AssociationName : ConcreteArgs[0], NthArgumentNamespace = ConcreteArgs[0] extends `${string} as ${infer Alias extends string}` ? Alias : ConcreteArgs[0], NthArgument extends VALID | INVALID | INVALID_NON_TERMINAL_ARRAY | INVALID_NAMESPACE_REUSE | INVALID_POLYMORPHIC_BELONGS_TO_JOIN | INVALID_CONSTRAINT_ON_REQUIRED_BELONGS_TO = ConcreteArgs['length'] extends 0 ? VALID : ConcreteArgs[0] extends (keyof SchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName> | AllowedNamesForNthArg ? RecursionType extends 'load' ? VALID : NthArgumentNamespace extends UsedNamespaces ? INVALID_NAMESPACE_REUSE : IsPolymorphicBelongsToAssociation<Schema, ConcreteTableName, UnaliasedNthArg> extends true ? INVALID_POLYMORPHIC_BELONGS_TO_JOIN : VALID : ConcreteArgs[0] extends readonly unknown[] ? INVALID_NON_TERMINAL_ARRAY : ConcreteArgs[0] extends JoinAndStatements<LastDream, DB, Schema, ConcreteTableName, RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>> ? RecursionType extends 'join' ? VALID : IsNonOptionalBelongsToAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> extends true ? INVALID_CONSTRAINT_ON_REQUIRED_BELONGS_TO : VALID : INVALID> = NthArgument extends INVALID_NON_TERMINAL_ARRAY ? `an array of association names is only allowed as the final argument (argument ${Inc<Depth>})` : NthArgument extends INVALID_NAMESPACE_REUSE ? `association name or alias already used earlier in this chain (argument ${Inc<Depth>})` : NthArgument extends INVALID_POLYMORPHIC_BELONGS_TO_JOIN ? `cannot join a polymorphic BelongsTo association (argument ${Inc<Depth>})` : NthArgument extends INVALID_CONSTRAINT_ON_REQUIRED_BELONGS_TO ? `${CannotConstrainRequiredBelongsTo} (argument ${Inc<Depth>})` : NthArgument extends INVALID ? `invalid where clause in argument ${Inc<Depth>}` : ConcreteArgs['length'] extends 0 ? AssociationNamesOrOnClause : VariadicRecurse<I, DB, Schema, ConcreteTableName, ConcreteArgs, RecursionType, UsedNamespaces, Depth, PreviousConcreteTableName, ConcreteAssociationName, LastDream>;
+export type VariadicLeftJoinLoadArgs<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], LastArg = never, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], PolymorphicBelongsToNames = PolymorphicBelongsToAssociationNames<Schema, ConcreteTableName>, AllowedNextArgValues = Exclude<keyof SchemaAssociations & string, PolymorphicBelongsToNames> | Exclude<AliasedSchemaAssociation<Schema, ConcreteTableName>, `${PolymorphicBelongsToNames & string} as ${string}`>> = WithoutStrayConditionKeys<LastArg, VariadicCheckThenRecurse<I, DB, Schema, ConcreteTableName, ConcreteArgs, 'leftJoinLoad', Camelized<ConcreteTableName>, 0, null, never, AllowedNextArgValues | Readonly<AllowedNextArgValues[]>>>;
+export type VariadicJoinsArgs<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], LastArg = never, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], PolymorphicBelongsToNames = PolymorphicBelongsToAssociationNames<Schema, ConcreteTableName>, AllowedNextArgValues = Exclude<keyof SchemaAssociations & string, PolymorphicBelongsToNames> | Exclude<AliasedSchemaAssociation<Schema, ConcreteTableName>, `${PolymorphicBelongsToNames & string} as ${string}`>> = WithoutStrayConditionKeys<LastArg, VariadicCheckThenRecurse<I, DB, Schema, ConcreteTableName, ConcreteArgs, 'join', Camelized<ConcreteTableName>, 0, null, never, AllowedNextArgValues>>;
+type VariadicCheckThenRecurse<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], RecursionType extends RecursionTypes, UsedNamespaces, Depth extends number, PreviousConcreteTableName, ConcreteAssociationName, AssociationNamesOrOnClause, LastDream extends Dream = I, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], AllowedNamesForNthArg = PreviousConcreteTableName extends keyof Schema ? AssociationNamesForAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> : keyof SchemaAssociations & string, UnaliasedNthArg = ConcreteArgs[0] extends `${infer AssociationName extends string} as ${string}` ? AssociationName : ConcreteArgs[0], NthArgumentNamespace = ConcreteArgs[0] extends `${string} as ${infer Alias extends string}` ? Alias : ConcreteArgs[0], NthArgument extends VALID | INVALID | INVALID_NON_TERMINAL_ARRAY | INVALID_NAMESPACE_REUSE | INVALID_POLYMORPHIC_BELONGS_TO_JOIN | INVALID_CONSTRAINT_ON_REQUIRED_BELONGS_TO = ConcreteArgs['length'] extends 0 ? VALID : ConcreteArgs[0] extends (keyof SchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName> | AllowedNamesForNthArg ? RecursionType extends 'load' ? VALID : NthArgumentNamespace extends UsedNamespaces ? INVALID_NAMESPACE_REUSE : IsPolymorphicBelongsToAssociation<Schema, ConcreteTableName, UnaliasedNthArg> extends true ? INVALID_POLYMORPHIC_BELONGS_TO_JOIN : VALID : ConcreteArgs[0] extends readonly unknown[] ? INVALID_NON_TERMINAL_ARRAY : ConcreteArgs[0] extends JoinAndStatements<LastDream, DB, Schema, ConcreteTableName, RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>> ? [
+    StrayConditionKeys<ConcreteArgs[0]>
+] extends [never] ? RecursionType extends 'join' ? VALID : IsNonOptionalBelongsToAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> extends true ? INVALID_CONSTRAINT_ON_REQUIRED_BELONGS_TO : VALID : INVALID : INVALID> = NthArgument extends INVALID_NON_TERMINAL_ARRAY ? `an array of association names is only allowed as the final argument (argument ${Inc<Depth>})` : NthArgument extends INVALID_NAMESPACE_REUSE ? `association name or alias already used earlier in this chain (argument ${Inc<Depth>})` : NthArgument extends INVALID_POLYMORPHIC_BELONGS_TO_JOIN ? `cannot join a polymorphic BelongsTo association (argument ${Inc<Depth>})` : NthArgument extends INVALID_CONSTRAINT_ON_REQUIRED_BELONGS_TO ? `${CannotConstrainRequiredBelongsTo} (argument ${Inc<Depth>})` : NthArgument extends INVALID ? `invalid where clause in argument ${Inc<Depth>}` : ConcreteArgs['length'] extends 0 ? AssociationNamesOrOnClause : VariadicRecurse<I, DB, Schema, ConcreteTableName, ConcreteArgs, RecursionType, UsedNamespaces, Depth, PreviousConcreteTableName, ConcreteAssociationName, LastDream>;
 export type AliasedSchemaAssociation<Schema, ConcreteTableName extends keyof Schema, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]]> = `${keyof SchemaAssociations & string} as ${string}`;
 type VariadicRecurse<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], RecursionType extends RecursionTypes, UsedNamespaces, Depth extends number, PreviousConcreteTableName, ConcreteAssociationName, LastDream extends Dream, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], UnaliasedNthArg = ConcreteArgs[0] extends `${infer AssociationName extends string} as ${string}` ? AssociationName : ConcreteArgs[0], PolymorphicTableNamesUnion = PreviousConcreteTableName extends keyof Schema ? AssociationTableNamesForAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> : ConcreteTableName, CrossPolymorphicTableForCurrentArg = UnaliasedNthArg extends string ? TableContainingAssociationInUnion<Schema, PolymorphicTableNamesUnion, UnaliasedNthArg> : never, EffectiveConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = UnaliasedNthArg extends keyof SchemaAssociations & string ? ConcreteTableName : [CrossPolymorphicTableForCurrentArg] extends [never] ? ConcreteTableName : CrossPolymorphicTableForCurrentArg extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB ? CrossPolymorphicTableForCurrentArg : ConcreteTableName, EffectiveSchemaAssociations = Schema[EffectiveConcreteTableName]['associations' & keyof Schema[EffectiveConcreteTableName]], IsAssociationNameOrAlias extends boolean = UnaliasedNthArg extends keyof EffectiveSchemaAssociations & string ? true : false, NextUnaliasedAssociationName = IsAssociationNameOrAlias extends true ? UnaliasedNthArg & keyof EffectiveSchemaAssociations & string : never, NextAliasedAssociationName = IsAssociationNameOrAlias extends true ? ConcreteArgs[0] extends `${string} as ${infer AssociationAlias extends string}` ? AssociationAlias : NextUnaliasedAssociationName : ConcreteAssociationName, NextPreviousConcreteTableName = IsAssociationNameOrAlias extends true ? EffectiveConcreteTableName : PreviousConcreteTableName, NextUsedNamespaces = RecursionType extends 'load' ? never : IsAssociationNameOrAlias extends true ? UsedNamespaces | NextAliasedAssociationName : UsedNamespaces, NextTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = IsAssociationNameOrAlias extends true ? AssociationTableName<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : ConcreteTableName, AllowedAssociationNames = IsAssociationNameOrAlias extends true ? AssociationNamesForAssociation<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : PreviousConcreteTableName extends keyof Schema ? AssociationNamesForAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> : AssociationNamesForTable<Schema, ConcreteTableName>, // fall back to association names for table for root only
 CurrentRequiredOnClauseKeys = IsAssociationNameOrAlias extends true ? RequiredOnClauseKeys<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>, CurrentAssociationIsNonOptionalBelongsTo = IsAssociationNameOrAlias extends true ? IsNonOptionalBelongsToAssociation<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : IsNonOptionalBelongsToAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName>, NextDreamCandidate = IsAssociationNameOrAlias extends true ? LastDream extends Dream ? NextUnaliasedAssociationName extends keyof LastDream ? DreamAssociationNameToAssociatedModel<LastDream, NextUnaliasedAssociationName & keyof LastDream> : never : never : LastDream, NextDream extends Dream = [NextDreamCandidate] extends [never] ? LastDream : NextDreamCandidate extends Dream ? NextDreamCandidate : LastDream, NextPolymorphicBelongsToNames = RecursionType extends 'load' ? never : PolymorphicBelongsToAssociationNames<Schema, NextTableName>, JoinSafeAllowedAssociationNames = Exclude<AllowedAssociationNames, NextPolymorphicBelongsToNames | `${NextPolymorphicBelongsToNames & string} as ${string}`>, AllowedNextArgValues = RecursionType extends 'load' ? AllowedNextArgValuesForLoad<NextDream, DB, Schema, AllowedAssociationNames, NextTableName, CurrentRequiredOnClauseKeys, CurrentAssociationIsNonOptionalBelongsTo> : RecursionType extends 'leftJoinLoad' ? AllowedNextArgValuesForLeftJoinLoad<NextDream, DB, Schema, JoinSafeAllowedAssociationNames, NextTableName, CurrentRequiredOnClauseKeys, NextUsedNamespaces, CurrentAssociationIsNonOptionalBelongsTo> : RecursionType extends 'join' ? AllowedNextArgValuesForJoin<NextDream, DB, Schema, JoinSafeAllowedAssociationNames, NextTableName, CurrentRequiredOnClauseKeys, NextUsedNamespaces> : never> = Depth extends MAX_VARIADIC_DEPTH ? never : VariadicCheckThenRecurse<I, DB, Schema, NextTableName, ReadonlyTail<ConcreteArgs>, RecursionType, NextUsedNamespaces, Inc<Depth>, NextPreviousConcreteTableName, [

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJyVk8FOAjEQht9lzgUpCwvboxATY0RNjB4Ih7I7uA3dlnS6mA3h3U3lsiK65dR2Mv/8X6fTAzhrPYFY8nQ8YZzzFQOHG425V9YQiANwzsNiZIUg4KVG18yd2qO7lYTAYKtMAYIPpwxqp0FAriUR0k2x7p9l90tfaWCnDBDgqegFee8UYJCXShcODYhlMhitjgySwajl/tAQ6qZVtcP/V/41BDxJpgEhrC2GZ0v+wyHFU1xQdHAE13TY7vusxHw7s4a8k8r4N2W1DE/0nzU6Zx31/5LGMCRZm8HqujJPe3QbbT9jnH8IYvzGk5bfXHp5b3Jb7aRXa43vypchtpaEdwp1EYHQWeOqiUiHnIWmMJ5OUsbT7HtGw+EM+7XZ4en2YfeoqJI+LyN5L4tj2pe1P8vC+kWt9TWjci7p8jwevwDboG8X"
+window.hierarchyData = "eJyVklFPwjAQx7/LPVf0GGxjj0JMjBE1MfpAeCjb4Rq6lrQdZiF8d1N5qYiuPLVp7t/fr9fbg9HaWSgWmE5yhohLBobWkkontLJQ7AER/aJ4Q1DAS0ummxmxI3PLLQGDjVAVFDjMGbRGQgGl5NaSva5Wg5PqQe0aCexYAQU4W135+NXxgEFZC1kZUlAsEhwtDwwSHAX0h86S7IJbe/i/6i8xwCSdeAW/Bg7P2roPQzbe4kyix8NT03QYUKc1lZupVtYZLpR7E1py/0X/ockYbezgr2iMQ34TOmjZNuppR2Yt9WcM+UcghjfJA96MO36vSt1suRMrSe/C1f5sxS3dCZJVhELvHRdNRJoOmW8Kwwwzhlky/h6QDLMT7dduS8fX+92jsA13ZR3pez4c0b4sGQcec+3mrZSXjMpppI95OHwBEYFvHQ=="

package/docs/assets/highlight.css

@@ -19,12 +19,10 @@
     --dark-hl-8: #B5CEA8;
     --light-hl-9: #267F99;
     --dark-hl-9: #4EC9B0;
-    --light-hl-10: #CD3131;
-    --dark-hl-10: #F44747;
-    --light-hl-11: #000000FF;
-    --dark-hl-11: #D4D4D4;
-    --light-hl-12: #EE0000;
-    --dark-hl-12: #D7BA7D;
+    --light-hl-10: #000000FF;
+    --dark-hl-10: #D4D4D4;
+    --light-hl-11: #EE0000;
+    --dark-hl-11: #D7BA7D;
     --light-code-background: #FFFFFF;
     --dark-code-background: #1E1E1E;
 }
@@ -42,7 +40,6 @@
     --hl-9: var(--light-hl-9);
     --hl-10: var(--light-hl-10);
     --hl-11: var(--light-hl-11);
-    --hl-12: var(--light-hl-12);
     --code-background: var(--light-code-background);
 } }
 
@@ -59,7 +56,6 @@
     --hl-9: var(--dark-hl-9);
     --hl-10: var(--dark-hl-10);
     --hl-11: var(--dark-hl-11);
-    --hl-12: var(--dark-hl-12);
     --code-background: var(--dark-code-background);
 } }
 
@@ -76,7 +72,6 @@
     --hl-9: var(--light-hl-9);
     --hl-10: var(--light-hl-10);
     --hl-11: var(--light-hl-11);
-    --hl-12: var(--light-hl-12);
     --code-background: var(--light-code-background);
 }
 
@@ -93,7 +88,6 @@
     --hl-9: var(--dark-hl-9);
     --hl-10: var(--dark-hl-10);
     --hl-11: var(--dark-hl-11);
-    --hl-12: var(--dark-hl-12);
     --code-background: var(--dark-code-background);
 }
 
@@ -109,5 +103,4 @@
 .hl-9 { color: var(--hl-9); }
 .hl-10 { color: var(--hl-10); }
 .hl-11 { color: var(--hl-11); }
-.hl-12 { color: var(--hl-12); }
 pre, code { background: var(--code-background); }

package/docs/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "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"
+window.navigationData = "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"