@getstrata/core 0.5.99 → 0.5.101

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @getstrata/core changelog
 
+## 0.5.101
+
+- Tenant middleware falls back with explicit branches when a member, admin, or guest tenant lookup misses, so the request still scopes to the default tenant.
+
+## 0.5.100
+
+HiroApp dogfood of 0.5.99: eager `with()` / nested `load("a.b")` missed related rows when a Postgres int4 PK arrived as a JS `number` and an int8 FK as a `bigint`. Map matching used `===`.
+
+- Relation indexers and eager attach compare keys with `relationMatchKey` (`1`, `1n`, `"1"` match).
+- Sequential `load("position")` / `application.position()` already used SQL `get()` and were unaffected.
+- `registerModelRepository(User, users)` already names `User` and `$morphClass`. Do not also call `registerModelClass("User", User)`. `registerModelClass` is only for an alias that is neither `constructor.name` nor `$morphClass`.
+
+Still non-conforming (honest): Bun cannot infer `morphTo()` method names. `hashed` cast is a no-op. `Factory.has()` without a bound model still needs an explicit FK.
+
 ## 0.5.99
 
 HiroApp dogfood of 0.5.98 found lookalike APIs. This release matches Laravel call shape and SQL, not just export names.

package/dist/core/database/baseRepository.d.ts

@@ -1,5 +1,5 @@
 import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
-import { type BelongsToManyRelation, type BelongsToRelation, type HasManyRelation, type MorphManyRelation, type MorphOneRelation, type MorphToRelation } from "./relationships.ts";
+import { type BelongsToManyRelation, type BelongsToRelation, type HasManyRelation, type HasManyThroughRelation, type MorphManyRelation, type MorphOneRelation, type MorphToRelation } from "./relationships.ts";
 import { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
 import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
@@ -59,6 +59,10 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     }>>;
     findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
     loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
+    findHasManyThrough<TParent extends object, LocalKey extends keyof TParent & string, FirstKey extends string, SecondLocalKey extends string, SecondKey extends keyof TEntity & string>(parentId: unknown, relation: HasManyThroughRelation<TParent, TEntity, LocalKey, FirstKey, SecondLocalKey, SecondKey>, options?: QueryOptions<TEntity>): Promise<TEntity[]>;
+    loadHasManyThroughForParents<TParent extends object, LocalKey extends keyof TParent & string, FirstKey extends string, SecondLocalKey extends string, SecondKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyThroughRelation<TParent, TEntity, LocalKey, FirstKey, SecondLocalKey, SecondKey>, options?: QueryOptions<TEntity>): Promise<Map<TParent[LocalKey], TEntity[]>>;
+    private throughSoftDeleteClause;
+    private buildThroughWhere;
     loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
     loadMorphManyForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphManyRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
     loadMorphOneForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphOneRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity | undefined>>;

package/dist/core/database/index.d.ts

@@ -5,10 +5,10 @@ export { mapDatabaseError, withDatabaseErrorHandling } from "./errors.ts";
 export { Factory } from "./factory.ts";
 export { foreignKeyFromTable, pivotTableName, singularize } from "./inflection.ts";
 export type { CastType, GlobalScopeFn, ModelConstructor } from "./model.ts";
-export { applyCasts, BelongsToManyRelationQuery, BelongsToRelationQuery, dehydrateValue, filterMassAssignable, HasManyRelationQuery, HasOneRelationQuery, hydrateValue, Model, ModelQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, registerModelClass, registerModelRepository, } from "./model.ts";
+export { applyCasts, BelongsToManyRelationQuery, BelongsToRelationQuery, dehydrateValue, filterMassAssignable, HasManyRelationQuery, HasManyThroughRelationQuery, HasOneRelationQuery, hydrateValue, Model, ModelQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, registerModelClass, registerModelRepository, } from "./model.ts";
 export { buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, } from "./query.ts";
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "./relationships.ts";
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } from "./relationships.ts";
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "./relationships.ts";
+export { belongsTo, belongsToMany, hasMany, hasManyThrough, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasManyThroughRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } from "./relationships.ts";
 export { RepositoryQuery } from "./repositoryQuery.ts";
 export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "./schema/index.ts";
 export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "./schema/index.ts";

package/dist/core/database/model.d.ts

@@ -1,6 +1,6 @@
 import type BaseRepository from "./baseRepository.ts";
 import type { AnyRelationQuery, RelatedModelClass } from "./relationQuery.ts";
-import { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery } from "./relationQuery.ts";
+import { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasManyThroughRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery } from "./relationQuery.ts";
 import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation } from "./relationships.ts";
 import type { RepositoryQuery } from "./repositoryQuery.ts";
 import type { QueryOptions, QueryWhere } from "./types.ts";
@@ -25,6 +25,7 @@ type ModelObserver = {
     deleting?: (model: AnyModel) => unknown;
     deleted?: (model: AnyModel) => unknown;
 };
+/** Alias for `hasMany("Name")` when `Name` is not `constructor.name` or `$morphClass`. */
 declare function registerModelClass(name: string, model: object): void;
 declare function hydrateValue(value: unknown, cast: CastType): unknown;
 declare function dehydrateValue(value: unknown, cast: CastType): unknown;
@@ -55,6 +56,9 @@ declare class ModelQuery {
     withMorphMany(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withMorphMany"]>): this;
     withMorphOne(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withMorphOne"]>): this;
     withMorphTo(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withMorphTo"]>): this;
+    withHasManyThrough(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withHasManyThrough"]>): this;
+    withTrashed(): this;
+    onlyTrashed(): this;
     get(): Promise<Array<Model<Record<string, unknown>, "id">>>;
     first(): Promise<Model<Record<string, unknown>, "id"> | null>;
     find(id: unknown): Promise<Model<Record<string, unknown>, "id"> | null>;
@@ -102,6 +106,21 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     static newFromRecord(this: object, record: object, exists?: boolean): Model<Record<string, unknown>, "id">;
     static create(this: object, attributes: Record<string, unknown>, forced?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
     static with(this: object, ...relations: string[]): ModelQuery;
+    static withTrashed(this: object): ModelQuery;
+    static onlyTrashed(this: object): ModelQuery;
+    static chunk(this: object, count: number, callback: (models: Array<Model<Record<string, unknown>, "id">>) => Promise<boolean | void>): Promise<void>;
+    static cursorPaginate(this: object, options: {
+        perPage: number;
+        cursor?: unknown;
+    }): Promise<{
+        data: Array<Model<Record<string, unknown>, "id">>;
+        meta: {
+            per_page: number;
+            next_cursor: unknown;
+            prev_cursor: unknown;
+            has_more: boolean;
+        };
+    }>;
     static whereHas(this: object, name: string, constrain?: (query: AnyRelationQuery) => void): ModelQuery;
     static has(this: object, name: string): ModelQuery;
     static doesntHave(this: object, name: string): ModelQuery;
@@ -126,6 +145,7 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     hasMany<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, foreignKey?: keyof TRelated & string, localKey?: PrimaryKey): HasManyRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
     hasOne<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, foreignKey?: keyof TRelated & string, localKey?: PrimaryKey): HasOneRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
     belongsTo<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, foreignKey?: keyof TEntity & string, ownerKey?: RelatedKey): BelongsToRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
+    hasManyThrough<TRelated extends object, TThrough extends object, RelatedKey extends keyof TRelated & string, ThroughKey extends keyof TThrough & string>(related: RelatedRef<TRelated, RelatedKey>, through: RelatedRef<TThrough, ThroughKey>, firstKey?: string, secondKey?: keyof TRelated & string, localKey?: PrimaryKey, secondLocalKey?: ThroughKey): HasManyThroughRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
     belongsToMany<TRelated extends object, RelatedKey extends keyof TRelated & string, Pivot extends object = Record<string, unknown>>(related: RelatedRef<TRelated, RelatedKey>, pivotTable?: string, foreignPivotKey?: keyof Pivot & string, relatedPivotKey?: keyof Pivot & string): BelongsToManyRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey, Pivot>;
     morphMany<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, morphName: string, typeKey?: keyof TRelated & string, idKey?: keyof TRelated & string, morphType?: string): MorphManyRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
     morphOne<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, morphName: string, typeKey?: keyof TRelated & string, idKey?: keyof TRelated & string, morphType?: string): MorphOneRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
@@ -135,7 +155,8 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     setLoaded(name: string, value: unknown): this;
     mergeAttributes(patch: Partial<TEntity>): this;
 }
+/** Binds a Model class to its table/connection and names it for `hasMany("User")`. */
 declare function registerModelRepository<TModelClass>(model: TModelClass, repository: object): TModelClass;
-export { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, } from "./relationQuery.ts";
+export { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasManyThroughRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, } from "./relationQuery.ts";
 export type { CastType, GlobalScopeFn, ModelClassType, ModelConstructor };
 export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, ModelQuery, registerModelClass, registerModelRepository, };

package/dist/core/database/relationQuery.d.ts

@@ -1,5 +1,5 @@
 import type BaseRepository from "./baseRepository.ts";
-import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
+import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
 import type { RepositoryQuery } from "./repositoryQuery.ts";
 import type { QueryOptions, QueryWhere } from "./types.ts";
 type RelatedRecord = {
@@ -17,7 +17,7 @@ interface RelationHost<TEntity extends object, PrimaryKey extends keyof TEntity
     get<K extends keyof TEntity>(key: K): TEntity[K];
     getRepository(): BaseRepository<TEntity, PrimaryKey>;
 }
-type RelationKind = "hasMany" | "hasOne" | "belongsTo" | "belongsToMany" | "morphMany" | "morphOne" | "morphTo";
+type RelationKind = "hasMany" | "hasOne" | "belongsTo" | "belongsToMany" | "hasManyThrough" | "morphMany" | "morphOne" | "morphTo";
 type ExistsClause = {
     sql: string;
     params: unknown[];
@@ -159,6 +159,25 @@ declare class MorphToRelationQuery<TChild extends object, ChildKey extends keyof
     get(): Promise<RelatedRecord | null>;
     then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
 }
+declare class HasManyThroughRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TFar extends object, FarKey extends keyof TFar & string> {
+    private readonly parent;
+    private readonly related;
+    readonly relation: HasManyThroughRelation<TParent, TFar, ParentKey, string, string, keyof TFar & string>;
+    readonly kind: RelationKind;
+    private extraWhere;
+    private extraOptions;
+    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TFar, FarKey>, relation: HasManyThroughRelation<TParent, TFar, ParentKey, string, string, keyof TFar & string>);
+    where(where: QueryWhere<TFar>): this;
+    orderBy(orderBy: QueryOptions<TFar>["orderBy"]): this;
+    limit(limit: number): this;
+    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
+    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
+    toExistsClause(parentTable: string): ExistsClause;
+    get(): Promise<RelatedRecord[]>;
+    first(): Promise<RelatedRecord | null>;
+    count(): Promise<number>;
+    then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
+}
 type AnyRelationQuery = {
     kind: RelationKind;
     applyEagerLoad(query: unknown, alias: string): void;
@@ -169,4 +188,4 @@ type AnyRelationQuery = {
     then?: (onfulfilled?: ((value: unknown) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null) => Promise<unknown>;
 };
 export type { AnyRelationQuery, RelatedModelClass, RelatedRecord, RelationHost };
-export { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, };
+export { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasManyThroughRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, };

package/dist/core/database/relationships.d.ts

@@ -25,6 +25,16 @@ interface BelongsToManyRelation<TParent, TRelated, Pivot extends object, ParentK
     foreignPivotKey: ForeignPivotKey;
     relatedPivotKey: RelatedPivotKey;
 }
+interface HasManyThroughRelation<TParent, TFar, LocalKey extends keyof TParent & string = keyof TParent & string, FirstKey extends string = string, SecondLocalKey extends string = string, SecondKey extends keyof TFar & string = keyof TFar & string> {
+    type: "hasManyThrough";
+    name: string;
+    throughTable: string;
+    localKey: LocalKey;
+    firstKey: FirstKey;
+    secondLocalKey: SecondLocalKey;
+    secondKey: SecondKey;
+    throughParentKey?: string;
+}
 declare function hasMany<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, ForeignKey extends keyof TChild & string = keyof TChild & string>(definition: {
     name: string;
     localKey: LocalKey;
@@ -40,6 +50,15 @@ declare function belongsTo<TChild, TParent, ForeignKey extends keyof TChild & st
     foreignKey: ForeignKey;
     ownerKey: OwnerKey;
 }): BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>;
+declare function hasManyThrough<TParent, TFar, LocalKey extends keyof TParent & string = keyof TParent & string, FirstKey extends string = string, SecondLocalKey extends string = string, SecondKey extends keyof TFar & string = keyof TFar & string>(definition: {
+    name: string;
+    throughTable: string;
+    localKey: LocalKey;
+    firstKey: FirstKey;
+    secondLocalKey: SecondLocalKey;
+    secondKey: SecondKey;
+    throughParentKey?: string;
+}): HasManyThroughRelation<TParent, TFar, LocalKey, FirstKey, SecondLocalKey, SecondKey>;
 declare function belongsToMany<TParent, TRelated, Pivot extends object, ParentKey extends keyof TParent & string = keyof TParent & string, RelatedKey extends keyof TRelated & string = keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string = keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string = keyof Pivot & string>(definition: {
     name: string;
     pivotTable: string;
@@ -48,6 +67,8 @@ declare function belongsToMany<TParent, TRelated, Pivot extends object, ParentKe
     foreignPivotKey: ForeignPivotKey;
     relatedPivotKey: RelatedPivotKey;
 }): BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>;
+declare function relationMatchKey(value: unknown): string;
+declare function getByRelationKey<K, V>(map: ReadonlyMap<K, V>, key: unknown): V | undefined;
 declare function indexHasManyRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasManyRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild[]>;
 declare function indexHasOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasOneRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild | undefined>;
 declare function indexBelongsToRelation<TChild, TParent, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parents: readonly TParent[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>): Map<TChild[ForeignKey], TParent>;
@@ -95,6 +116,7 @@ declare function morphTo<TChild, MorphTypeKey extends keyof TChild & string = ke
 }): MorphToRelation<TChild, MorphTypeKey, MorphIdKey>;
 declare function indexMorphManyRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphManyRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild[]>;
 declare function indexMorphOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphOneRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild | undefined>;
-declare function indexMorphToRelation<TChild, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parentsByType: ReadonlyMap<string, ReadonlyMap<TParent[OwnerKey], TParent>>, relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>): Map<TChild[MorphIdKey], TParent>;
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, };
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, };
+declare function indexHasManyThroughRelation<TParent, TFar, LocalKey extends keyof TParent & string, FirstKey extends string, SecondLocalKey extends string, SecondKey extends keyof TFar & string>(parents: readonly TParent[], children: readonly (TFar & Record<string, unknown>)[], relation: HasManyThroughRelation<TParent, TFar, LocalKey, FirstKey, SecondLocalKey, SecondKey>): Map<TParent[LocalKey], TFar[]>;
+declare function indexMorphToRelation<TChild, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, _OwnerKey extends keyof TParent & string = keyof TParent & string>(children: readonly TChild[], parentsByType: ReadonlyMap<string, ReadonlyMap<unknown, TParent>>, relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>): Map<TChild[MorphIdKey], TParent>;
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, };
+export { belongsTo, belongsToMany, getByRelationKey, hasMany, hasManyThrough, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasManyThroughRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, relationMatchKey, };

package/dist/core/database/repositoryQuery.d.ts

@@ -1,6 +1,6 @@
 import type { PaginatedResult } from "../pagination/index.ts";
 import type BaseRepository from "./baseRepository.ts";
-import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
+import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
 import type { QueryOptions, QueryWhere } from "./types.ts";
 import { WhereBuilder } from "./whereBuilder.ts";
 type LoadedRow = Record<string, unknown>;
@@ -31,6 +31,9 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     withMorphOne<TChild extends object, LocalKey extends keyof TEntity & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: MorphOneRelation<TEntity, TChild, LocalKey, MorphTypeKey, MorphIdKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
     withMorphTo<TParent extends object, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string, Alias extends string>(as: Alias, relation: MorphToRelation<TEntity, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, keyof TParent & string>>, options?: Omit<QueryOptions<TParent>, "where">): this;
     withBelongsToMany<TRelated extends object, Pivot extends object, ParentKey extends keyof TEntity & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string, Alias extends string>(as: Alias, relation: BelongsToManyRelation<TEntity, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>, relatedRepository: BaseRepository<TRelated, RelatedKey>, options?: Omit<QueryOptions<TRelated>, "where">): this;
+    withHasManyThrough<TFar extends object, LocalKey extends keyof TEntity & string, SecondKey extends keyof TFar & string, Alias extends string>(as: Alias, relation: HasManyThroughRelation<TEntity, TFar, LocalKey, string, string, SecondKey>, farRepository: BaseRepository<TFar, keyof TFar & string>, options?: Omit<QueryOptions<TFar>, "where">): this;
+    withTrashed(): this;
+    onlyTrashed(): this;
     get(): Promise<Array<TEntity & LoadedRow>>;
     first(): Promise<(TEntity & LoadedRow) | null>;
     count(): Promise<number>;

package/dist/entries/database/model.js

@@ -775,7 +775,8 @@ class BelongsToManyRelationQuery {
       return;
     }
     const list = Array.isArray(ids) ? ids : [ids];
-    await this.connection().unsafe(`DELETE FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1 AND ${String(this.relation.relatedPivotKey)} = ANY($2)`, [parentId, list]);
+    const placeholders = list.map((_, index) => `$${index + 2}`).join(", ");
+    await this.connection().unsafe(`DELETE FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1 AND ${String(this.relation.relatedPivotKey)} IN (${placeholders})`, [parentId, ...list]);
   }
   async sync(ids) {
     await this.detach();
@@ -957,6 +958,65 @@ class MorphToRelationQuery {
   }
 }
 
+class HasManyThroughRelationQuery {
+  parent;
+  related;
+  relation;
+  kind = "hasManyThrough";
+  extraWhere = {};
+  extraOptions = {};
+  constructor(parent, related, relation) {
+    this.parent = parent;
+    this.related = related;
+    this.relation = relation;
+  }
+  where(where) {
+    this.extraWhere = { ...this.extraWhere, ...where };
+    return this;
+  }
+  orderBy(orderBy) {
+    this.extraOptions = { ...this.extraOptions, orderBy };
+    return this;
+  }
+  limit(limit) {
+    this.extraOptions = { ...this.extraOptions, limit };
+    return this;
+  }
+  applyEagerLoad(query, alias) {
+    query.withHasManyThrough(alias, this.relation, this.related.repository(), this.extraOptions);
+  }
+  hydrateEager(row, alias) {
+    const value = row[alias] ?? [];
+    const rows = Array.isArray(value) ? value : [];
+    return rows.map((item) => this.related.newFromRecord(item));
+  }
+  toExistsClause(parentTable) {
+    const farTable = this.related.repository().getTable().name;
+    const extra = buildAdvancedWhereClause(farTable, this.extraWhere, [], []);
+    const extraSql = extra.clause.replace(/^ WHERE /, "");
+    const sql = `SELECT 1 FROM ${quoteIdentifier(farTable)} INNER JOIN ${quoteIdentifier(this.relation.throughTable)} ON ${qualifyColumn(this.relation.throughTable, this.relation.secondLocalKey)} = ${qualifyColumn(farTable, this.relation.secondKey)} WHERE ${qualifyColumn(this.relation.throughTable, this.relation.firstKey)} = ${qualifyColumn(parentTable, this.relation.localKey)}${extraSql ? ` AND ${extraSql}` : ""}`;
+    return { sql, params: extra.params };
+  }
+  async get() {
+    const rows = await this.related.repository().withConnection(this.parent.getRepository().getConnection()).findHasManyThrough(this.parent.get(this.relation.localKey), this.relation, {
+      ...this.extraOptions,
+      where: this.extraWhere
+    });
+    return rows.map((row) => this.related.newFromRecord(row));
+  }
+  async first() {
+    const rows = await this.limit(1).get();
+    return rows[0] ?? null;
+  }
+  async count() {
+    const rows = await this.get();
+    return rows.length;
+  }
+  then(onfulfilled, onrejected) {
+    return thenGet(() => this.get(), onfulfilled, onrejected);
+  }
+}
+
 // ../../src/core/database/relationships.ts
 function hasMany(definition) {
   return {
@@ -976,32 +1036,80 @@ function belongsTo(definition) {
     ...definition
   };
 }
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
 function belongsToMany(definition) {
   return {
     type: "belongsToMany",
     ...definition
   };
 }
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
+  }
+  return String(value);
+}
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
+  }
+  const want = relationMatchKey(key);
+  if (want === "") {
+    return;
+  }
+  for (const [existing, value] of map) {
+    if (relationMatchKey(existing) === want) {
+      return value;
+    }
+  }
+  return;
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
-    const key = child[relation.foreignKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexHasOneRelation(parents, children, relation) {
   const grouped = indexHasManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
@@ -1009,12 +1117,12 @@ function indexHasOneRelation(parents, children, relation) {
 function indexBelongsToRelation(children, parents, relation) {
   const parentsById = new Map;
   for (const parent of parents) {
-    parentsById.set(parent[relation.ownerKey], parent);
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
   }
   const result = new Map;
   for (const child of children) {
     const foreignKey = child[relation.foreignKey];
-    const parent = parentsById.get(foreignKey);
+    const parent = parentsById.get(relationMatchKey(foreignKey));
     if (parent) {
       result.set(foreignKey, parent);
     }
@@ -1024,23 +1132,33 @@ function indexBelongsToRelation(children, parents, relation) {
 function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
   const relatedById = new Map;
   for (const related of relatedRows) {
-    relatedById.set(related[relation.relatedKey], related);
+    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
   }
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.parentKey], []);
+    const key = relationMatchKey(parent[relation.parentKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.parentKey]);
+    }
   }
   for (const pivot of pivotRows) {
-    const parentId = pivot[relation.foreignPivotKey];
-    const relatedId = pivot[relation.relatedPivotKey];
-    const group = groups.get(parentId);
-    const related = relatedById.get(relatedId);
+    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
+    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
     if (!group || !related) {
       continue;
     }
     group.push(related);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function morphMany(definition) {
   return {
@@ -1062,31 +1180,62 @@ function morphTo(definition) {
 }
 function indexMorphManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
     if (child[relation.morphTypeKey] !== relation.morphType) {
       continue;
     }
-    const key = child[relation.morphIdKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexMorphOneRelation(parents, children, relation) {
   const grouped = indexMorphManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
 }
+function indexHasManyThroughRelation(parents, children, relation) {
+  const throughKey = relation.throughParentKey ?? "__through_parent_id";
+  const grouped = new Map;
+  for (const child of children) {
+    const key = relationMatchKey(child[throughKey]);
+    if (key === "") {
+      continue;
+    }
+    const existing = grouped.get(key) ?? [];
+    const { [throughKey]: _through, ...far } = child;
+    existing.push(far);
+    grouped.set(key, existing);
+  }
+  const result = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    result.set(parent[relation.localKey], grouped.get(key) ?? []);
+  }
+  return result;
+}
 function indexMorphToRelation(children, parentsByType, relation) {
   const result = new Map;
   for (const child of children) {
@@ -1095,7 +1244,7 @@ function indexMorphToRelation(children, parentsByType, relation) {
     if (!parents) {
       continue;
     }
-    const parent = parents.get(child[relation.morphIdKey]);
+    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
     if (parent) {
       result.set(child[relation.morphIdKey], parent);
     }
@@ -1431,6 +1580,18 @@ class ModelQuery {
     this.query.withMorphTo(...args);
     return this;
   }
+  withHasManyThrough(...args) {
+    this.query.withHasManyThrough(...args);
+    return this;
+  }
+  withTrashed() {
+    this.query.withTrashed();
+    return this;
+  }
+  onlyTrashed() {
+    this.query.onlyTrashed();
+    return this;
+  }
   async get() {
     const statics = modelStatics(this.modelClass);
     const rows = await this.query.get();
@@ -1638,6 +1799,31 @@ class Model {
   static with(...relations) {
     return Model.query.call(this).with(...relations);
   }
+  static withTrashed() {
+    return Model.query.call(this).withTrashed();
+  }
+  static onlyTrashed() {
+    return Model.query.call(this).onlyTrashed();
+  }
+  static async chunk(count, callback) {
+    const statics = modelStatics(this);
+    ensureBooted(this);
+    await resolveModelRepository(this).chunk(count, async (rows) => {
+      return await callback(rows.map((row) => statics.newFromRecord(row, true)));
+    });
+  }
+  static async cursorPaginate(options) {
+    const statics = modelStatics(this);
+    ensureBooted(this);
+    const page = await resolveModelRepository(this).cursorPaginate({
+      perPage: options.perPage,
+      cursor: options.cursor
+    });
+    return {
+      data: page.data.map((row) => statics.newFromRecord(row, true)),
+      meta: page.meta
+    };
+  }
   static whereHas(name, constrain) {
     return Model.query.call(this).whereHas(name, constrain);
   }
@@ -1762,7 +1948,7 @@ class Model {
   }
   async loadHasMany(as, relation, childRepository, options = {}) {
     const grouped = await childRepository.withConnection(this.repository.getConnection()).loadHasManyForParents([this.attributes], relation, options);
-    const loaded = grouped.get(this.attributes[relation.localKey]) ?? [];
+    const loaded = getByRelationKey(grouped, this.attributes[relation.localKey]) ?? [];
     return Object.assign(this, { [as]: loaded });
   }
   async loadHasOne(as, relation, childRepository, options = {}) {
@@ -1772,7 +1958,7 @@ class Model {
   }
   async loadBelongsTo(as, relation, parentRepository, options = {}) {
     const grouped = await this.repository.loadBelongsToForParents([this.attributes], relation, parentRepository, options);
-    const loaded = grouped.get(this.attributes[relation.foreignKey]);
+    const loaded = getByRelationKey(grouped, this.attributes[relation.foreignKey]);
     return Object.assign(this, { [as]: loaded });
   }
   async loadBelongsToMany(as, relation, relatedRepository, options = {}) {
@@ -1792,7 +1978,7 @@ class Model {
       }
     });
     const grouped = indexBelongsToManyRelation([this.attributes], pivotRows, relatedRows, relation);
-    const loaded = grouped.get(parentId) ?? [];
+    const loaded = getByRelationKey(grouped, parentId) ?? [];
     return Object.assign(this, { [as]: loaded });
   }
   hasMany(related, foreignKey, localKey) {
@@ -1822,6 +2008,20 @@ class Model {
       ownerKey: ownerKey ?? relatedTable.primaryKey
     }));
   }
+  hasManyThrough(related, through, firstKey, secondKey, localKey, secondLocalKey) {
+    const table = this.repository.getTable();
+    const relatedClass = resolveRelated(related);
+    const throughClass = resolveRelated(through);
+    const throughTable = throughClass.repository().getTable();
+    return new HasManyThroughRelationQuery(this, relatedClass, hasManyThrough({
+      name: relatedClass.repository().getTable().name,
+      throughTable: throughTable.name,
+      localKey: localKey ?? table.primaryKey,
+      firstKey: firstKey ?? foreignKeyFromTable(table.name),
+      secondLocalKey: secondLocalKey ?? throughTable.primaryKey,
+      secondKey: secondKey ?? foreignKeyFromTable(throughTable.name)
+    }));
+  }
   belongsToMany(related, pivotTable, foreignPivotKey, relatedPivotKey) {
     const table = this.repository.getTable();
     const relatedClass = resolveRelated(related);
@@ -1913,6 +2113,7 @@ export {
   BelongsToManyRelationQuery,
   BelongsToRelationQuery,
   HasManyRelationQuery,
+  HasManyThroughRelationQuery,
   HasOneRelationQuery,
   Model,
   ModelQuery,