@getstrata/core 0.5.100 → 0.5.101

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @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 `===`.

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";
@@ -56,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>;
@@ -103,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;
@@ -127,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>;
@@ -138,6 +157,6 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
 }
 /** 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;
@@ -97,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 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, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, };
-export { belongsTo, belongsToMany, getByRelationKey, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, relationMatchKey, };
+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,6 +1036,13 @@ function belongsTo(definition) {
     ...definition
   };
 }
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
 function belongsToMany(definition) {
   return {
     type: "belongsToMany",
@@ -1149,6 +1216,26 @@ function indexMorphOneRelation(parents, children, relation) {
   }
   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) {
@@ -1493,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();
@@ -1700,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);
   }
@@ -1884,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);
@@ -1975,6 +2113,7 @@ export {
   BelongsToManyRelationQuery,
   BelongsToRelationQuery,
   HasManyRelationQuery,
+  HasManyThroughRelationQuery,
   HasOneRelationQuery,
   Model,
   ModelQuery,

package/dist/entries/database/relationships.js

@@ -18,6 +18,13 @@ function belongsTo(definition) {
     ...definition
   };
 }
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
 function belongsToMany(definition) {
   return {
     type: "belongsToMany",
@@ -191,6 +198,26 @@ function indexMorphOneRelation(parents, children, relation) {
   }
   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) {
@@ -211,10 +238,12 @@ export {
   belongsToMany,
   getByRelationKey,
   hasMany,
+  hasManyThrough,
   hasOne,
   indexBelongsToManyRelation,
   indexBelongsToRelation,
   indexHasManyRelation,
+  indexHasManyThroughRelation,
   indexHasOneRelation,
   indexMorphManyRelation,
   indexMorphOneRelation,

package/dist/entries/database/repositoryQuery.js

@@ -441,6 +441,13 @@ function belongsTo(definition) {
     ...definition
   };
 }
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
 function belongsToMany(definition) {
   return {
     type: "belongsToMany",
@@ -614,6 +621,26 @@ function indexMorphOneRelation(parents, children, relation) {
   }
   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) {
@@ -797,6 +824,24 @@ class RepositoryQuery {
     });
     return this;
   }
+  withHasManyThrough(as, relation, farRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "hasManyThrough",
+      as,
+      relation,
+      repository: farRepository,
+      options
+    });
+    return this;
+  }
+  withTrashed() {
+    this.queryOptions = { ...this.queryOptions, withTrashed: true };
+    return this;
+  }
+  onlyTrashed() {
+    this.queryOptions = { ...this.queryOptions, onlyTrashed: true };
+    return this;
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
@@ -882,6 +927,15 @@ class RepositoryQuery {
         }));
         continue;
       }
+      if (load.kind === "hasManyThrough") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyThroughForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
+        }));
+        continue;
+      }
       if (load.kind === "belongsToMany") {
         const relation2 = load.relation;
         const grouped2 = await this.repository.loadBelongsToManyForParents(rows, relation2, load.repository, load.options);

package/dist/entries/openapi/generator.js

@@ -94,10 +94,30 @@ var PUBLIC_ROUTE_DESCRIPTIONS = {
   "POST /billing/webhooks/stripe": "Stripe webhook receiver (stub)",
   "GET /scim/v2/Users": "SCIM list users",
   "POST /scim/v2/Users": "SCIM create user",
-  "GET /scim/v2/Groups": "SCIM list groups (organizations)",
   "GET /health": "Liveness probe",
   "GET /ready": "Readiness probe",
-  "GET /metrics": "Prometheus metrics"
+  "GET /metrics": "Prometheus metrics",
+  "GET /api/user": "Current authenticated HiroApp user",
+  "POST /api/login": "Login with email and password",
+  "POST /api/logout": "Log out the current cookie session",
+  "POST /api/auth/two-factor-challenge": "Complete staff two-factor login challenge",
+  "GET /api/users/me": "Current user profile",
+  "PATCH /api/users/me": "Update profile name and email",
+  "PUT /api/users/me/password": "Change password",
+  "GET /api/users/me/sessions": "List cookie browser sessions",
+  "DELETE /api/users/me/sessions/:id": "Revoke one cookie browser session",
+  "GET /api/auth/tokens": "List API tokens",
+  "POST /api/auth/tokens": "Create API token",
+  "DELETE /api/auth/tokens/:id": "Revoke API token",
+  "GET /api/applications": "List applications",
+  "POST /api/applications": "Submit an application",
+  "GET /api/positions": "List hiring positions",
+  "GET /api/departments": "List departments",
+  "GET /api/webhooks": "List hiring webhooks",
+  "POST /api/webhooks": "Create a hiring webhook",
+  "GET /api/audit-logs": "List hiring audit log entries",
+  "GET /api/billing/subscription": "Current tenant subscription",
+  "GET /scim/v2/Groups": "SCIM list groups (departments)"
 };
 function toOpenApiPath(path) {
   return path.replace(/:([A-Za-z_]+)/g, "{$1}");

package/dist/index.js

@@ -2078,6 +2078,13 @@ function belongsTo(definition) {
     ...definition
   };
 }
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
 function belongsToMany(definition) {
   return {
     type: "belongsToMany",
@@ -2251,6 +2258,26 @@ function indexMorphOneRelation(parents, children, relation) {
   }
   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) {
@@ -2434,6 +2461,24 @@ class RepositoryQuery {
     });
     return this;
   }
+  withHasManyThrough(as, relation, farRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "hasManyThrough",
+      as,
+      relation,
+      repository: farRepository,
+      options
+    });
+    return this;
+  }
+  withTrashed() {
+    this.queryOptions = { ...this.queryOptions, withTrashed: true };
+    return this;
+  }
+  onlyTrashed() {
+    this.queryOptions = { ...this.queryOptions, onlyTrashed: true };
+    return this;
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
@@ -2519,6 +2564,15 @@ class RepositoryQuery {
         }));
         continue;
       }
+      if (load.kind === "hasManyThrough") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyThroughForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
+        }));
+        continue;
+      }
       if (load.kind === "belongsToMany") {
         const relation2 = load.relation;
         const grouped2 = await this.repository.loadBelongsToManyForParents(rows, relation2, load.repository, load.options);
@@ -2807,6 +2861,55 @@ class BaseRepository {
     }, options);
     return indexHasManyRelation(parents, children, relation);
   }
+  async findHasManyThrough(parentId, relation, options = {}) {
+    const grouped = await this.loadHasManyThroughForParents([{ [relation.localKey]: parentId }], relation, options);
+    return getByRelationKey(grouped, parentId) ?? [];
+  }
+  async loadHasManyThroughForParents(parents, relation, options = {}) {
+    if (parents.length === 0) {
+      return indexHasManyThroughRelation(parents, [], relation);
+    }
+    const parentIds = [...new Set(parents.map((parent) => parent[relation.localKey]))];
+    const throughParentKey = relation.throughParentKey ?? "__through_parent_id";
+    const farTable = this.table.name;
+    const columns = this.table.columns.map((column) => `${qualifyColumn(farTable, column)}`).join(", ");
+    const placeholders = parentIds.map((_, index) => `$${index + 1}`).join(", ");
+    const { text: extraWhere, params: extraParams } = this.buildThroughWhere(options, parentIds.length);
+    const softDelete = this.throughSoftDeleteClause(options);
+    const sql = `SELECT ${columns}, ${qualifyColumn(relation.throughTable, relation.firstKey)} AS ${throughParentKey} FROM ${quoteIdentifier(farTable)} INNER JOIN ${quoteIdentifier(relation.throughTable)} ON ${qualifyColumn(relation.throughTable, relation.secondLocalKey)} = ${qualifyColumn(farTable, relation.secondKey)} WHERE ${qualifyColumn(relation.throughTable, relation.firstKey)} IN (${placeholders})${softDelete}${extraWhere}`;
+    const children = await this.connection.unsafe(sql, [
+      ...parentIds,
+      ...extraParams
+    ]);
+    return indexHasManyThroughRelation(parents, children, relation);
+  }
+  throughSoftDeleteClause(options) {
+    const column = resolveSoftDeleteColumn(this.table);
+    if (!column) {
+      return "";
+    }
+    const qualified = qualifyColumn(this.table.name, column);
+    if (options.onlyTrashed) {
+      return ` AND ${qualified} IS NOT NULL`;
+    }
+    if (options.withTrashed) {
+      return "";
+    }
+    return ` AND ${qualified} IS NULL`;
+  }
+  buildThroughWhere(options, paramOffset = 1) {
+    const where = options.where ?? {};
+    const entries = Object.entries(where);
+    if (entries.length === 0) {
+      return { text: "", params: [] };
+    }
+    const params = [];
+    const clauses = entries.map(([column, value], index) => {
+      params.push(value);
+      return `${qualifyColumn(this.table.name, column)} = $${paramOffset + index + 1}`;
+    });
+    return { text: ` AND ${clauses.join(" AND ")}`, params };
+  }
   async loadBelongsToForParents(children, relation, parentRepository, options = {}) {
     if (children.length === 0) {
       return new Map;
@@ -2872,7 +2975,8 @@ class BaseRepository {
       return indexBelongsToManyRelation(parents, [], [], relation);
     }
     const parentIds = [...new Set(parents.map((parent) => parent[relation.parentKey]))];
-    const pivotRows = await this.connection.unsafe(`SELECT * FROM ${relation.pivotTable} WHERE ${String(relation.foreignPivotKey)} = ANY($1)`, [parentIds]);
+    const placeholders = parentIds.map((_, index) => `$${index + 1}`).join(", ");
+    const pivotRows = await this.connection.unsafe(`SELECT * FROM ${relation.pivotTable} WHERE ${String(relation.foreignPivotKey)} IN (${placeholders})`, parentIds);
     if (pivotRows.length === 0) {
       return indexBelongsToManyRelation(parents, [], [], relation);
     }
@@ -3534,7 +3638,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();
@@ -3716,6 +3821,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/model.ts
 var modelRepositories = new WeakMap;
 var namedModels = new Map;
@@ -4044,6 +4208,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();
@@ -4251,6 +4427,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);
   }
@@ -4435,6 +4636,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);
@@ -8076,17 +8291,33 @@ async function resolveTenantForRequest(request) {
         if (Number.isInteger(parsedHeader) && parsedHeader > 0 && parsedHeader !== userTenantId) {
           throw new ForbiddenError("Tenant header does not match your account.");
         }
-        return await resolveTenant(userTenantId) ?? DEFAULT_TENANT;
+        const memberTenant = await resolveTenant(userTenantId);
+        if (memberTenant) {
+          return memberTenant;
+        }
+        return DEFAULT_TENANT;
       }
       if (Number.isInteger(parsedHeader) && parsedHeader > 0) {
-        return await resolveTenant(parsedHeader) ?? DEFAULT_TENANT;
+        const headerTenant = await resolveTenant(parsedHeader);
+        if (headerTenant) {
+          return headerTenant;
+        }
+        return DEFAULT_TENANT;
+      }
+      const adminTenant = await resolveTenant(userTenantId);
+      if (adminTenant) {
+        return adminTenant;
       }
-      return await resolveTenant(userTenantId) ?? DEFAULT_TENANT;
+      return DEFAULT_TENANT;
     }
   }
   const headerTenantId = Number.isInteger(parsedHeader) && parsedHeader > 0 ? parsedHeader : null;
   const tenantId = isPublicReadsEnabled() && headerTenantId !== null ? headerTenantId : DEFAULT_TENANT.id;
-  return await resolveTenant(tenantId) ?? DEFAULT_TENANT;
+  const guestTenant = await resolveTenant(tenantId);
+  if (guestTenant) {
+    return guestTenant;
+  }
+  return DEFAULT_TENANT;
 }
 function createTenantMiddleware() {
   return async (request, next) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "0.5.100",
+  "version": "0.5.101",
   "description": "Strata — Laravel-inspired Bun framework public API",
   "type": "module",
   "license": "MIT",