@rvoh/dream 2.13.0 → 2.14.0-beta.1

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

@@ -9,7 +9,7 @@ export class Range {
         this.begin = begin;
         this.end = end;
         this.excludeEnd = excludeEnd;
-        if (!begin && !end)
+        if (begin == null && end == null)
             throw new Error('Must pass either begin or end to a range');
     }
 }

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

@@ -1660,10 +1660,10 @@ export default class Dream {
      * //       as: 'ratings',
      * //       polymorphic: true,
      * //       source: 'ratings',
-     * //       where: undefined,
-     * //       whereNot: undefined,
-     * //       selfWhere: undefined,
-     * //       selfWhereNot: undefined,
+     * //       and: undefined,
+     * //       andNot: undefined,
+     * //       selfAnd: undefined,
+     * //       selfAndNot: undefined,
      * //       primaryKeyOverride: null,
      * //       primaryKey: [Function: primaryKey],
      * //       primaryKeyValue: [Function: primaryKeyValue],

package/dist/types/src/db/migration-helpers/DreamMigrationHelpers.d.ts

@@ -1,4 +1,4 @@
-import { Kysely } from 'kysely';
+import { ColumnDataType, Kysely } from 'kysely';
 export default class DreamMigrationHelpers {
     /**
      * Rename a table and its associated primary key index and sequence.
@@ -141,6 +141,95 @@ export default class DreamMigrationHelpers {
      * @param __namedParameters.replacements - Details about which table and column to change and which value to replace the dropped value with (or remove it if the column is an array)
      */
     static dropEnumValue(db: Kysely<any>, { enumName, value, replacements }: DropValueFromEnumOpts): Promise<void>;
+    /**
+     * Convert an existing plaintext column into the encrypted-backed form expected by
+     * the `@Encrypted` decorator.
+     *
+     * This renames `column` to `encrypted_<column>`, widens it to `text`, and rewrites
+     * every non-null value with the AES-GCM ciphertext produced by the exact same code
+     * path the decorator's setter uses (`InternalEncrypt.encryptColumn`). After it runs,
+     * the column holds real ciphertext that the decorator's getter can decrypt — which is
+     * what a bare column rename does **not** do (renaming a plaintext column to
+     * `encrypted_<column>` and decorating the property leaves plaintext in the column, so
+     * the getter throws `DecryptionError`).
+     *
+     * The encryption key and algorithm come from the application's encryption config
+     * (`DreamApp` `encryption.columns.current`); if encryption is not configured this
+     * throws `MissingColumnEncryptionOpts`. Null values are left null.
+     *
+     * Intended for text/string columns (the common case is text -> encrypted text). The
+     * column is widened to `text` before reading, so values are encrypted as their text
+     * form; the inverse `decryptColumn` can restore a non-text type via its `columnType`
+     * option.
+     *
+     * ```ts
+     * // plaintext `phone` column -> encrypted `encrypted_phone` text column
+     * await DreamMigrationHelpers.encryptColumn(db, { table: 'users', column: 'phone' })
+     * ```
+     *
+     * **Rewrites rows one at a time** (each value needs a fresh random IV computed in Node,
+     * so the rewrite cannot be a single SQL `UPDATE`), reading them in keyset batches of
+     * `batchSize` to bound memory. It still holds the table for the migration's duration; on
+     * very large tables do not use this helper — write your own batched / online migration.
+     *
+     * **Drop any index on the column first.** Per-row updates pay index-maintenance cost on
+     * every write, and an index over ciphertext is useless anyway (encrypted values are not
+     * queryable). Remove the index before this migration and do not re-add it.
+     *
+     * @param db - The Kysely database object passed into the migration up/down function
+     * @param options - Configuration options
+     * @param options.table - The name of the table
+     * @param options.column - The current (plaintext) column name
+     * @param options.encryptedColumnName - The target encrypted column name. Defaults to `encrypted_<column>`, matching the `@Encrypted` decorator's default; pass this when the decorator was given a custom encrypted column name.
+     * @param options.primaryKey - The primary key column used to keyset-paginate and target each row's update. Defaults to `id`.
+     * @param options.batchSize - How many rows to read per batch. Defaults to `1000`.
+     */
+    static encryptColumn(db: Kysely<any>, { table, column, encryptedColumnName, primaryKey, batchSize, }: EncryptColumnOpts): Promise<void>;
+    /**
+     * Inverse of {@link DreamMigrationHelpers.encryptColumn}: decrypt an
+     * `encrypted_<column>` column back to plaintext and rename it to `column`.
+     *
+     * Every non-null value is decrypted with the same path the decorator's getter uses
+     * (`InternalEncrypt.decryptColumn`, which honors both the `current` and `legacy`
+     * encryption keys), then the column is renamed back. Called with the same `table` and
+     * `column`, this exactly reverses `encryptColumn`.
+     *
+     * By default the column is left as `text`, because the original column type cannot be
+     * recovered from the encrypted state. Pass `columnType` to restore a specific type
+     * (e.g. `'integer'`); the conversion runs `ALTER COLUMN ... TYPE <columnType> USING
+     * <column>::<columnType>`.
+     *
+     * ```ts
+     * await DreamMigrationHelpers.decryptColumn(db, { table: 'users', column: 'phone' })
+     *
+     * // restore the original column type as part of the inverse
+     * await DreamMigrationHelpers.decryptColumn(db, { table: 'users', column: 'age', columnType: 'integer' })
+     * ```
+     *
+     * The same per-row, batched, table-locking caveat as `encryptColumn` applies.
+     *
+     * @param db - The Kysely database object passed into the migration up/down function
+     * @param options - Configuration options
+     * @param options.table - The name of the table
+     * @param options.column - The target (plaintext) column name to rename back to
+     * @param options.encryptedColumnName - The current encrypted column name. Defaults to `encrypted_<column>`.
+     * @param options.primaryKey - The primary key column used to keyset-paginate and target each row's update. Defaults to `id`.
+     * @param options.batchSize - How many rows to read per batch. Defaults to `1000`.
+     * @param options.columnType - When provided, the restored column is converted to this type. When omitted, the column is left as `text`.
+     */
+    static decryptColumn(db: Kysely<any>, { table, column, encryptedColumnName, primaryKey, batchSize, columnType, }: DecryptColumnOpts): Promise<void>;
+    /**
+     * Walk every non-null value of `column` in keyset batches of `batchSize`, applying
+     * `transform` in Node and writing the result back one row at a time. Keyset pagination
+     * on `primaryKey` (`WHERE pk > last ORDER BY pk`) bounds memory to a single batch and
+     * guarantees forward progress, so a row is never read — or transformed — twice (which
+     * matters because the transform is not idempotent: re-encrypting ciphertext would
+     * double-encrypt, and re-decrypting plaintext would throw).
+     *
+     * Reads alias the selected columns to fixed keys via `sql.ref(...).as(...)` so a
+     * `CamelCasePlugin` on the connection cannot rename the result keys.
+     */
+    private static transformColumnInBatches;
 }
 interface DropValueFromEnumOpts {
     enumName: string;
@@ -154,11 +243,11 @@ interface DropValueFromEnumTablesAndColumnsForArrayBase {
     array: true;
 }
 interface DropValueWithRemovalFromEnumTablesAndColumnsForArray extends DropValueFromEnumTablesAndColumnsForArrayBase {
-    behavior: 'replace';
-    replaceWith: string;
+    behavior: 'remove';
 }
 interface DropValueWithReplacementFromEnumTablesAndColumnsForArray extends DropValueFromEnumTablesAndColumnsForArrayBase {
-    behavior: 'remove';
+    behavior: 'replace';
+    replaceWith: string;
 }
 type DropValueFromEnumTablesAndColumnsForNonArray = {
     table: string;
@@ -169,4 +258,19 @@ interface AddValueToEnumOpts {
     enumName: string;
     value: string;
 }
+interface EncryptColumnOpts {
+    table: string;
+    column: string;
+    encryptedColumnName?: string;
+    primaryKey?: string;
+    batchSize?: number;
+}
+interface DecryptColumnOpts {
+    table: string;
+    column: string;
+    encryptedColumnName?: string;
+    primaryKey?: string;
+    batchSize?: number;
+    columnType?: ColumnDataType;
+}
 export {};

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

@@ -0,0 +1,42 @@
+import type DreamApp from '../dream-app/index.js';
+/**
+ * The number of databases in the pre-created pool (including the unsuffixed
+ * base at index 1). Shared by the CLI pool-creation / drop loops and the claim
+ * probe so they always agree on the index range.
+ */
+export declare function testDatabasePoolSize(parallelTests: number | undefined): number;
+/**
+ * The database name for a pool index given the un-suffixed base name. Index 1
+ * is the base itself (no suffix); higher indexes are `<base>_<index>`. This is
+ * the single naming rule, used by both the claim path and the CLI loops.
+ */
+export declare function testDatabaseNameForIndex(baseName: string, index: number): string;
+/**
+ * Sync read of the already-claimed pool index, or null if no claim has
+ * completed yet in this process. `DreamApp.dbName()` (synchronous, called when
+ * Kysely builds a pool) relies on the claim having been awaited earlier in the
+ * worker — `DreamApp.init()` awaits {@link claimTestDatabase} before the first
+ * connection is built, and `truncate` awaits it too — so by the time any
+ * connection resolves its database name the index is populated.
+ */
+export declare function claimedTestDatabaseIndexOrNull(): number | null;
+/**
+ * Claim a free pool database for this worker (idempotent). On first call it
+ * opens the default driver's dedicated lock session, probes
+ * {@link TestDatabaseLockSession.tryAcquire} across the pool indexes until one
+ * succeeds, and caches the claimed index for the rest of the process.
+ * Subsequent calls (and concurrent callers) return the same index.
+ *
+ * Throws a loud, actionable error if the pool is genuinely exhausted after the
+ * wait-for-free window — telling the reader to recreate the pool with
+ * `<packageManager> psy db:reset`.
+ */
+export declare function claimTestDatabase(dreamApp: DreamApp): Promise<number>;
+/**
+ * Test-only escape hatch for dream's own spec suite: release the claim and
+ * close the lock session so a test can exercise the claim machinery in
+ * isolation. Not part of the public API.
+ *
+ * @internal
+ */
+export declare function __resetTestDatabaseClaimForSpec(): Promise<void>;

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

@@ -121,6 +121,30 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      */
     static setDatabaseTypeParsers(connectionName: string): Promise<void>;
     static duplicateDatabase(connectionName: string): Promise<void>;
+    /**
+     * @internal
+     *
+     * Whether this driver implements the per-worker test-database claim seam
+     * ({@link openTestDatabaseLockSession}). Adapters that can hold a
+     * process-lifetime, auto-releasing lock to reserve one database from the
+     * test pool override this to `true`. It defaults to `false` so that a new
+     * adapter fails loud under vitest rather than silently sharing a single
+     * database across overlapping workers — see `src/db/testDatabasePool.ts`.
+     */
+    static supportsParallelTestDatabases: boolean;
+    /**
+     * @internal
+     *
+     * Open a dedicated, process-lifetime lock session used to claim one database
+     * from the per-worker test pool. Only ever called when
+     * {@link supportsParallelTestDatabases} is `true`; the base default throws.
+     *
+     * The returned session wraps a single dedicated connection: the orchestrator
+     * (`src/db/testDatabasePool.ts`) probes many pool indexes on the one session
+     * via `tryAcquire` and keeps whichever it acquires, holding it for the
+     * worker's lifetime.
+     */
+    static openTestDatabaseLockSession(connectionName: string): Promise<TestDatabaseLockSession>;
     static getColumnData(connectionName: string, tableName: string, allTableAssociationData: {
         [key: string]: SchemaBuilderAssociationData;
     }): Promise<{
@@ -327,3 +351,26 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
     hydratePreload(this: QueryDriverBase<DreamInstance>, dream: Dream): Promise<void>;
 }
 export type GenericDbType = 'datetime' | 'date';
+/**
+ * One dedicated lock session backing the per-worker test-database claim. The
+ * orchestrator (`src/db/testDatabasePool.ts`) opens one session per worker,
+ * probes pool indexes with {@link tryAcquire}, and keeps the first index it
+ * wins for the worker's lifetime.
+ *
+ * The session intentionally carries no adapter-specific lock-key type:
+ * `tryAcquire` takes a semantic `(namespace, index)` pair and each driver maps
+ * it to its own primitive (Postgres `pg_try_advisory_lock(int4, int4)`, MySQL
+ * `GET_LOCK`), so no Postgres int-pair leaks into the shared contract.
+ */
+export interface TestDatabaseLockSession {
+    /**
+     * Try to acquire the lock for `(namespace, index)` without blocking. Returns
+     * `true` if this session now holds it, `false` if another live session does.
+     * Must not wait — the orchestrator drives its own probe / wait-for-free loop.
+     */
+    tryAcquire(namespace: string, index: number): Promise<boolean>;
+    /**
+     * Close the underlying connection, releasing any lock it holds.
+     */
+    release(): Promise<void>;
+}

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

@@ -362,6 +362,17 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      * @returns A string
      */
     private namespaceColumn;
+    /**
+     * @internal
+     *
+     * Builds the table expression passed to Kysely's `innerJoin`/`leftJoin` for an
+     * association. When the alias already snakeifies to the table name, Kysely's
+     * CamelCasePlugin emits the correct identifier from the alias alone, so no
+     * explicit `as` clause is needed; otherwise we join the table aliased as `alias`.
+     *
+     * @returns A table expression string, e.g. `"beautiful_balloons as balloon"`
+     */
+    private aliasedJoinTableExpression;
     private checkForQueryViolations;
     private similarityStatementBuilder;
     /**

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

@@ -1,6 +1,7 @@
 import Dream from '../../Dream.js';
 import { SchemaBuilderAssociationData, SchemaBuilderColumnData } from '../../helpers/cli/ASTBuilder.js';
 import KyselyQueryDriver from './Kysely.js';
+import type { TestDatabaseLockSession } from './Base.js';
 export default class PostgresQueryDriver<DreamInstance extends Dream> extends KyselyQueryDriver<DreamInstance> {
     /**
      * create the database. Must respond to the NODE_ENV value.
@@ -33,4 +34,22 @@ export default class PostgresQueryDriver<DreamInstance extends Dream> extends Ky
         [key: string]: SchemaBuilderColumnData;
     }>;
     static duplicateDatabase(connectionName: string): Promise<void>;
+    static supportsParallelTestDatabases: boolean;
+    /**
+     * @internal
+     *
+     * Postgres implementation of the per-worker test-database claim seam (see
+     * {@link TestDatabaseLockSession} and `src/db/testDatabasePool.ts`).
+     *
+     * Postgres advisory locks are global to the cluster (not scoped to a single
+     * database), so one dedicated connection — to the `postgres` maintenance
+     * database — can reserve a pool index for the whole cluster. We use the
+     * two-`int4` form `pg_try_advisory_lock(key1, key2)`, whose lock space is
+     * distinct from the single-`bigint` form `pg_advisory_lock(bigint)` that
+     * application code typically uses, so a claim can never clash with an
+     * app-level advisory lock. `key1` folds a hash of the lock namespace (the
+     * base database name) into a fixed dream-pool constant; `key2` is the pool
+     * index. The lock auto-releases when the connection drops on process exit.
+     */
+    static openTestDatabaseLockSession(connectionName: string): Promise<TestDatabaseLockSession>;
 }

package/dist/types/src/dream-app/index.d.ts

@@ -148,12 +148,75 @@ export default class DreamApp {
     constructor(opts?: Partial<DreamAppOpts>);
     get models(): Record<string, typeof Dream>;
     get serializers(): Record<string, DreamModelSerializerType | SimpleObjectSerializerType>;
+    /**
+     * The database name to connect to for a given connection. In dev/prod this is
+     * simply the configured name. Under vitest (test env) it is the per-worker
+     * database claimed from the pool — see {@link testDatabaseClaimEnabled} and
+     * `src/db/testDatabasePool.ts`.
+     *
+     * This is synchronous because Kysely builds its `pg.Pool` synchronously. It
+     * reads the already-claimed pool index; the claim is awaited earlier in the
+     * worker — `DreamApp.init()` calls {@link claimTestDatabase} before the first
+     * connection is built, and `dream-spec-helpers`' `truncate` awaits
+     * {@link testDatabaseName} — so the index is always populated by the time any
+     * connection resolves its name.
+     */
     dbName(connectionName: string, connection: DbConnectionType): string;
+    /**
+     * Single source of truth for the claimed test-database name, used both by
+     * dream's connection resolution and by `dream-spec-helpers`' `truncate`
+     * (which opens its own `pg.Client` and so must read — not recompute — the
+     * claim). Awaits the pool claim if it has not happened yet in this worker.
+     */
+    testDatabaseName(connectionName: string, connection: DbConnectionType): Promise<string>;
+    /**
+     * Claim this worker's pool database if it hasn't been claimed yet. Idempotent
+     * and a no-op outside the test-under-vitest path. Called by `DreamApp.init()`
+     * before any connection is built so the synchronous {@link dbName} always
+     * sees a populated index.
+     */
+    ensureTestDatabaseClaimed(): Promise<void>;
     dbConnectionConfig(connectionName: string, connection: DbConnectionType): DreamDbConfig;
     dbConnectionQueryDriverClass<T extends Dream = Dream>(connectionName: string): typeof QueryDriverBase<T>;
     dbConnectionKeys(): string[];
     hasReplicaConfig(connectionName: string): boolean;
-    get parallelDatabasesEnabled(): boolean;
+    /**
+     * Whether the runtime *requires* a per-worker test-database claim. Gated on
+     * test env *under vitest* (not on `parallelTests > 1`): the slot-reuse
+     * collision reproduces even serially, because vitest respawns a process per
+     * file and the lingering process overlaps the new one on the same database.
+     * CLI db tasks (`db:migrate`, `db:reset`, …) do not run under vitest, so they
+     * keep the unsuffixed name and operate on the whole pool explicitly.
+     *
+     * This is independent of whether the default driver can actually claim — when
+     * the need is present but the capability is absent, the claim path fails loud
+     * (see {@link requireTestDatabaseClaimSupport}) rather than silently sharing
+     * one database.
+     */
+    get runtimeNeedsTestDatabaseClaim(): boolean;
+    /**
+     * Whether the default connection's query driver implements the per-worker
+     * test-database claim seam (`openTestDatabaseLockSession`). The claim is keyed
+     * off the **default** connection's capability so a Postgres-default app with a
+     * MySQL secondary keeps working (the secondary borrows the Postgres-claimed
+     * index for its database name).
+     */
+    private get defaultConnectionSupportsParallelTestDatabases();
+    /**
+     * Whether the per-worker test-database pool claim is active: needed by the
+     * runtime *and* supported by the default connection's driver. Consumers that
+     * key behavior off the claimed index (connection-cache suffixing) use this;
+     * the claim entry points additionally fail loud when the need is present but
+     * support is absent.
+     */
+    get testDatabaseClaimEnabled(): boolean;
+    /**
+     * Throw an actionable error when the runtime needs a per-worker test-database
+     * claim but the default connection's driver cannot provide one — rather than
+     * silently sharing a single database across overlapping vitest workers (which
+     * reintroduces the flake this whole mechanism exists to fix).
+     */
+    private requireTestDatabaseClaimSupport;
     load<RT extends 'models' | 'serializers'>(resourceType: RT, resourcePath: string, importCb: (path: string) => Promise<any>): Promise<void>;
     plugin(cb: (app: DreamApp) => void | Promise<void>): void;
     set<ApplyOpt extends DreamAppSetOption>(applyOption: ApplyOpt, options: ApplyOpt extends 'bypassDeprecationChecks' ? boolean : ApplyOpt extends 'db' ? DreamDbCredentialOptions | string : ApplyOpt extends 'encryption' ? DreamAppEncryptionOptions : ApplyOpt extends 'primaryKeyType' ? LegacyCompatiblePrimaryKeyType : ApplyOpt extends 'importExtension' ? GeneratorImportStyle : ApplyOpt extends 'logger' ? DreamLogger : ApplyOpt extends 'projectRoot' ? string : ApplyOpt extends 'inflections' ? () => void | Promise<void> : ApplyOpt extends 'packageManager' ? DreamAppAllowedPackageManagersEnum : ApplyOpt extends 'paths' ? DreamDirectoryPaths : ApplyOpt extends 'parallelTests' ? number : ApplyOpt extends 'unicodeNormalization' ? UnicodeNormalizationForm : ApplyOpt extends 'paginationPageSize' ? number : never, secondaryOptions?: ApplyOpt extends 'db' ? DreamDbCredentialOptions : never): void;

package/dist/types/src/helpers/areEqual.d.ts

@@ -1,6 +1,6 @@
 /**
  * Performs a deep equality check between two values, supporting primitives, arrays,
- * Dream instances, CalendarDate, DateTime, and objects.
+ * Dream instances, CalendarDate, DateTime, ClockTime, ClockTimeTz, and objects.
  *
  * Examples:
  *   areEqual(undefined, undefined) // true

package/dist/types/src/helpers/range.d.ts

@@ -1,9 +1,13 @@
-import CalendarDate from '../utils/datetime/CalendarDate.js';
-import { DateTime } from '../utils/datetime/DateTime.js';
-export default function range<T, U extends T extends null ? any : T extends DateTime | CalendarDate ? DateTime | CalendarDate : T>(begin: T, end?: U | null, excludeEnd?: boolean): Range<T, U>;
-export declare class Range<T, U extends T extends null ? any : T extends DateTime | CalendarDate ? DateTime | CalendarDate : T = T extends null ? any : T extends DateTime | CalendarDate ? DateTime | CalendarDate : T> {
+import type CalendarDate from '../utils/datetime/CalendarDate.js';
+import type ClockTime from '../utils/datetime/ClockTime.js';
+import type ClockTimeTz from '../utils/datetime/ClockTimeTz.js';
+import type { DateTime } from '../utils/datetime/DateTime.js';
+type RangeEndType<T> = T extends null ? any : T extends DateTime | CalendarDate ? DateTime | CalendarDate : T extends ClockTime ? ClockTime : T extends ClockTimeTz ? ClockTimeTz : T;
+export default function range<T, U extends RangeEndType<T>>(begin: T, end?: U | null, excludeEnd?: boolean): Range<T, U>;
+export declare class Range<T, U extends RangeEndType<T> = RangeEndType<T>> {
     readonly begin: T | null;
     readonly end: U | null;
     readonly excludeEnd: boolean;
     constructor(begin: T | null, end?: U | null, excludeEnd?: boolean);
 }
+export {};

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

@@ -59,7 +59,7 @@ type DecrementTable = {
     12: 11;
     13: 12;
     14: 13;
-    15: 15;
+    15: 14;
     16: 15;
     17: 16;
     18: 17;

package/dist/types/src/types/utils.ts

@@ -74,7 +74,7 @@ type DecrementTable = {
   12: 11
   13: 12
   14: 13
-  15: 15
+  15: 14
   16: 15
   17: 16
   18: 17

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

@@ -23,7 +23,7 @@ export type VariadicJoinsArgs<I extends Dream, DB, Schema, ConcreteTableName ext
 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]], AllowedNamesForArrayArg = PreviousConcreteTableName extends keyof Schema ? AssociationNamesForAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> : keyof SchemaAssociations & string, NthArgument extends VALID | INVALID = ConcreteArgs['length'] extends 0 ? VALID : ConcreteArgs[0] extends keyof SchemaAssociations & string ? VALID : ConcreteArgs[0] extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? VALID : ConcreteArgs[0] extends JoinAndStatements<LastDream, DB, Schema, ConcreteTableName, RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>> ? VALID : ConcreteArgs[0] extends readonly AllowedNamesForArrayArg[] ? VALID : ConcreteArgs[0] extends JoinAndStatements<LastDream, DB, Schema, ConcreteTableName, RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>> ? VALID : ConcreteArgs[0] extends AllowedNamesForArrayArg ? VALID : INVALID> = 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]], PolymorphicTableNamesUnion = PreviousConcreteTableName extends keyof Schema ? AssociationTableNamesForAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> : ConcreteTableName, CrossPolymorphicTableForCurrentArg = ConcreteArgs[0] extends string ? TableContainingAssociationInUnion<Schema, PolymorphicTableNamesUnion, ConcreteArgs[0]> : never, EffectiveConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = ConcreteArgs[0] 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]], ConcreteNthArg extends (keyof SchemaAssociations & string) | (keyof EffectiveSchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName> | null = ConcreteArgs[0] extends undefined ? null : ConcreteArgs[0] extends null ? null : ConcreteArgs[0] extends keyof SchemaAssociations & string ? ConcreteArgs[0] & keyof SchemaAssociations & string : ConcreteArgs[0] extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? ConcreteArgs[0] & AliasedSchemaAssociation<Schema, ConcreteTableName> : ConcreteArgs[0] extends keyof EffectiveSchemaAssociations & string ? ConcreteArgs[0] & keyof EffectiveSchemaAssociations & string : null, NextUsedNamespaces = ConcreteArgs[0] extends undefined ? never : ConcreteArgs[0] extends null ? never : ConcreteNthArg extends null ? UsedNamespaces : UsedNamespaces | ConcreteNthArg, CurrentArgumentType extends IS_ASSOCIATION_NAME | IS_ASSOCIATION_ALIAS | IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME | IS_NOT_ASSOCIATION_NAME = ConcreteNthArg extends null ? IS_NOT_ASSOCIATION_NAME : ConcreteNthArg extends keyof SchemaAssociations & string ? IS_ASSOCIATION_NAME : ConcreteNthArg extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? IS_ASSOCIATION_ALIAS : ConcreteNthArg extends keyof EffectiveSchemaAssociations & string ? IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME : IS_NOT_ASSOCIATION_NAME, NextPreviousConcreteTableName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteTableName : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteTableName : CurrentArgumentType extends IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME ? EffectiveConcreteTableName : PreviousConcreteTableName, NextUnaliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteNthArg : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteNthArg extends `${infer AssocName extends string} as ${string}` ? AssocName & keyof SchemaAssociations & string : never : CurrentArgumentType extends IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME ? ConcreteNthArg : never, NextAliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteNthArg : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteNthArg extends `${string} as ${infer AssocAlias extends string}` ? AssocAlias & string : ConcreteAssociationName : CurrentArgumentType extends IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME ? ConcreteNthArg : ConcreteAssociationName, IsAssociationNameOrAlias extends boolean = CurrentArgumentType extends IS_ASSOCIATION_NAME | IS_ASSOCIATION_ALIAS | IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME ? true : false, NextTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = IsAssociationNameOrAlias extends true ? AssociationTableName<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : ConcreteTableName & AssociationTableNames<DB, Schema> & keyof DB, 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
-AssociationTableOrConcreteTable extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = IsAssociationNameOrAlias extends true ? AssociationTableName<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : ConcreteTableName, CurrentRequiredOnClauseKeys = IsAssociationNameOrAlias extends true ? RequiredOnClauseKeys<Schema, EffectiveConcreteTableName, NextAliasedAssociationName> : RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>, AllowedNextArgValues = RecursionType extends 'load' ? AllowedNextArgValuesForLoad<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys> : RecursionType extends 'leftJoinLoad' ? AllowedNextArgValuesForLeftJoinLoad<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys, NextUsedNamespaces> : RecursionType extends 'join' ? AllowedNextArgValuesForJoin<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys, NextUsedNamespaces> : never> = Depth extends MAX_VARIADIC_DEPTH ? never : VariadicCheckThenRecurse<I, DB, Schema, NextTableName, ReadonlyTail<ConcreteArgs>, RecursionType, NextUsedNamespaces, Inc<Depth>, NextPreviousConcreteTableName, NextAliasedAssociationName, AllowedNextArgValues, DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream> extends Dream ? DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream> : LastDream>;
+AssociationTableOrConcreteTable extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = IsAssociationNameOrAlias extends true ? AssociationTableName<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : ConcreteTableName, CurrentRequiredOnClauseKeys = IsAssociationNameOrAlias extends true ? RequiredOnClauseKeys<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>, AllowedNextArgValues = RecursionType extends 'load' ? AllowedNextArgValuesForLoad<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys> : RecursionType extends 'leftJoinLoad' ? AllowedNextArgValuesForLeftJoinLoad<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys, NextUsedNamespaces> : RecursionType extends 'join' ? AllowedNextArgValuesForJoin<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys, NextUsedNamespaces> : never> = Depth extends MAX_VARIADIC_DEPTH ? never : VariadicCheckThenRecurse<I, DB, Schema, NextTableName, ReadonlyTail<ConcreteArgs>, RecursionType, NextUsedNamespaces, Inc<Depth>, NextPreviousConcreteTableName, NextAliasedAssociationName, AllowedNextArgValues, DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream> extends Dream ? DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream> : LastDream>;
 type AllowedNextArgValuesForLoad<I extends Dream, DB, Schema, AllowedNames, TableForJoin extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation> = AllowedNames | AllowedNames[] | JoinAndStatements<I, DB, Schema, TableForJoin, RequiredOnClauseKeysForThisAssociation>;
 type AllowedNextArgValuesForLeftJoinLoad<I extends Dream, DB, Schema, AllowedNames, TableForJoin extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation, UsedNamespaces> = Exclude<AllowedNames, UsedNamespaces> | Exclude<AllowedNames, UsedNamespaces>[] | JoinAndStatements<I, DB, Schema, TableForJoin, RequiredOnClauseKeysForThisAssociation>;
 type AllowedNextArgValuesForJoin<I extends Dream, DB, Schema, AllowedNames, TableForJoin extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation, UsedNamespaces> = Exclude<AllowedNames, UsedNamespaces> | JoinAndStatements<I, DB, Schema, TableForJoin, RequiredOnClauseKeysForThisAssociation>;

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

@@ -341,7 +341,7 @@ type VariadicRecurse<
     : ConcreteTableName,
   //
   CurrentRequiredOnClauseKeys = IsAssociationNameOrAlias extends true
-    ? RequiredOnClauseKeys<Schema, EffectiveConcreteTableName, NextAliasedAssociationName>
+    ? RequiredOnClauseKeys<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName>
     : RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>,
   //
   AllowedNextArgValues = RecursionType extends 'load'

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJyVks1uAiEURt/lrtE6P+LIspomTVPbJk27MC5w5tohMmCAsZkY372hbqi1HdwAIffjHOAewGjtLLBlQtOcTEcrAgY3EksntLLADjAd+VHxBoHBS4ummxuxR3PLLQKBrVAVsCQtCLRGAoNScmvR3lTr4Vn1sHaNBHKqAAbOVgMfH5w2CJS1kJVBBWyZZpPVkUCaTQL6Q2dRdsGpPfxf9dcYJBktvIKfA4dnbd2HQRtvcSHR4+Gp4yKkzmostzOtrDNcKPcmtOT+h/5DozHa2OFf0QgHOqKhg5Zto572aDZSf8aQfwRieGke8Obc8XtV6mbHnVhLfBeu9ntrbvFOoKwiFHrPuKojxkVB/KOQhOYZSShNvhuE5tmZ9mu3w9Pt/epR2Ia7so70vRyOeT6aBB4L7RatlNe0ynmkj3k8fgGG6267"
+window.hierarchyData = "eJyVksFOAyEQht9lzlgLtmTL0TYmxlg1MXpoeqC7U5eUhQbYmk3TdzfYC9bq0hOEzM/3McwenLXBg1hQzimhlC4JOFxrLIOyxoPYA6U0LkY2CAJeWnTdzKkdulvpEQhslKlAUFYQaJ0GAaWW3qO/rlaDk+pBHRoN5FgBAoKvrmL86nhAoKyVrhwaEAvG2fJAgHGW0B86j7pLbu3h/6q/xICOhjQqxDVxeLY+fDj0+RZnEj0ekcrZOKFOayw3U2t8cFKZ8KaslvGL/kOjc9b5wV/RHIfRTepgdduYpx26tbafOeQfgRweTzs9k0Hem9I2WxnUSuO7CnU8W0mPdwp1laHQe8dFE8HZmMSmEMqLIaF8UnwPCC+GJ9qv3RaPr4+7R+UbGco60/d8OKd9kyLxmNswb7W+ZFROI33Mw+ELlqZu/Q=="