@getstrata/core 0.5.98 → 0.5.100

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @getstrata/core changelog
 
+## 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.
+
+- Relation queries are thenable: `await user.applications()` delegates to `get()`.
+- `Model.with()` / `where()` / `whereHas()` return a `ModelQuery` that hydrates models and chains into `where` / `find` / `findOrFail` / `first` / `get`. `first()` / `find()` use `LIMIT` / PK lookup.
+- `belongsTo.where()` threads constraints into `whereHas` EXISTS (HiroApp application search).
+- `{ ilike }` uses the value as-is (Laravel). Pass `%term%` yourself; the operator no longer wraps extra `%`.
+- Morph type defaults to `$morphClass` / class name, not `table.name`. Override with `$morphClass = "App\\Models\\User"` or the last `morphMany` argument. `morphTo()` no longer silently defaults to `imageable_*`.
+- `primaryKey()` defaults to the table PK (`id`).
+- Nested `load("a.b")` / `with("a.b")` skip already-loaded heads and batch the next level.
+- `count()` is `COUNT(*)` (relations and `RepositoryQuery`).
+- `belongsToMany` eager-loads in two queries; `toggle()` and `withPivotValues()` exist. `hasMany.save($model)` sets the FK and saves.
+- Factory `for(parent)` infers `user_id` from a Model parent. Bound `model` uses `Model.create()` so observers fire.
+- `JsonResource.collection().toResponse()` wraps once: `{ data: [...] }`.
+- Observers: `saving` / `saved` / `retrieved`. Integer casts: `integer` / `int`.
+- `hasMany("Application")` / `() => Application` / `registerModelClass()` for ESM cycles.
+
+Still non-conforming (honest): Bun cannot infer `morphTo()` method names (`debug_backtrace` equivalent is empty). `hashed` cast is a no-op (bcrypt is async). `Factory.has()` without a model class still needs an explicit FK.
+
 ## 0.5.98
 
 - Eloquent-shaped relations: `this.hasMany(Related)` returns a relation query (`get`/`where`/`create`/`attach`). `load()` / `loaded()` and `Model.with()` replace PHP `__get`. `whereHas`/`has`/`doesntHave`, morph* methods, and nested `with("a.b")` are supported.

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

@@ -1,5 +1,5 @@
 import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
-import { type BelongsToRelation, type HasManyRelation, type MorphManyRelation, type MorphOneRelation, type MorphToRelation } from "./relationships.ts";
+import { type BelongsToManyRelation, type BelongsToRelation, type HasManyRelation, 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";
@@ -20,6 +20,7 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     protected readonly table: TableDefinition<TEntity, PrimaryKey>;
     protected readonly connection: DatabaseConnection;
     constructor(table: TableDefinition<TEntity, PrimaryKey>, connection?: DatabaseConnection);
+    count(options?: ExtendedQueryOptions<TEntity>): Promise<number>;
     findAll(options?: ExtendedQueryOptions<TEntity>): Promise<TEntity[]>;
     paginate(options: {
         page: number;
@@ -62,6 +63,7 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     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>>;
     loadMorphToForChildren<TChild extends object, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, OwnerKey>>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[MorphIdKey], TParent>>;
+    loadBelongsToManyForParents<TParent extends object, TRelated extends object, Pivot extends object, ParentKey extends keyof TParent & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string>(parents: readonly TParent[], relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>, relatedRepository: BaseRepository<TRelated, RelatedKey>, options?: Omit<QueryOptions<TRelated>, "where">): Promise<Map<TParent[ParentKey], TRelated[]>>;
 }
 export { BaseRepository };
 export default BaseRepository;

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

@@ -11,6 +11,11 @@ declare class Factory<TRecord extends object, Counted extends boolean = false> {
     private children;
     private afterMakingCallbacks;
     private afterCreatingCallbacks;
+    protected model?: {
+        create(attributes: Record<string, unknown>): Promise<{
+            toObject(): object;
+        }>;
+    };
     protected definition(): TRecord;
     protected clone(): this;
     count(quantity: number): Factory<TRecord, true>;
@@ -18,19 +23,29 @@ declare class Factory<TRecord extends object, Counted extends boolean = false> {
     sequence(...items: Array<FactorySequence<TRecord>>): Factory<TRecord, Counted>;
     for(parent: {
         id?: unknown;
-    }, foreignKey: keyof TRecord & string): Factory<TRecord, Counted>;
+        getRepository?: () => {
+            getTable(): {
+                name: string;
+            };
+        };
+    }, foreignKey?: keyof TRecord & string): Factory<TRecord, Counted>;
     recycle(parent: {
         id?: unknown;
-    }, foreignKey: keyof TRecord & string): Factory<TRecord, Counted>;
+        getRepository?: () => {
+            getTable(): {
+                name: string;
+            };
+        };
+    }, foreignKey?: keyof TRecord & string): Factory<TRecord, Counted>;
     afterMaking(callback: (record: TRecord) => void): Factory<TRecord, Counted>;
     afterCreating(callback: (record: TRecord) => void | Promise<void>): Factory<TRecord, Counted>;
-    has<TRelated extends object, RelatedCounted extends boolean>(factory: Factory<TRelated, RelatedCounted>, foreignKey: keyof TRelated & string): Factory<TRecord, Counted>;
+    has<TRelated extends object, RelatedCounted extends boolean>(factory: Factory<TRelated, RelatedCounted>, foreignKey?: keyof TRelated & string): Factory<TRecord, Counted>;
     make(overrides?: Partial<TRecord>): FactoryMakeResult<TRecord, Counted>;
     create(overrides?: Partial<TRecord>): Promise<FactoryMakeResult<TRecord, Counted>>;
     protected makeOne(overrides?: Partial<TRecord>): TRecord;
     protected createOne(overrides?: Partial<TRecord>): Promise<TRecord>;
     protected insertable(record: TRecord): Partial<TRecord>;
-    protected persist(_values: Partial<TRecord>): Promise<TRecord>;
+    protected persist(values: Partial<TRecord>): Promise<TRecord>;
 }
 export type { FactoryMakeResult };
 export { Factory };

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

@@ -5,7 +5,7 @@ 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, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, registerModelRepository, } from "./model.ts";
+export { applyCasts, BelongsToManyRelationQuery, BelongsToRelationQuery, dehydrateValue, filterMassAssignable, HasManyRelationQuery, 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";

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

@@ -4,7 +4,7 @@ import { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuer
 import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation } from "./relationships.ts";
 import type { RepositoryQuery } from "./repositoryQuery.ts";
 import type { QueryOptions, QueryWhere } from "./types.ts";
-type CastType = "date" | "datetime" | "json" | "bool" | "boolean";
+type CastType = "date" | "datetime" | "json" | "bool" | "boolean" | "integer" | "int" | "hashed";
 type LoadedAttributes = Record<string, unknown>;
 type ModelCasts = Partial<Record<string, CastType>>;
 type GlobalScopeFn<TEntity extends object, PrimaryKey extends keyof TEntity & string> = (query: RepositoryQuery<TEntity, PrimaryKey>) => RepositoryQuery<TEntity, PrimaryKey>;
@@ -13,18 +13,56 @@ interface ModelConstructor<TEntity extends object, PrimaryKey extends keyof TEnt
     new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): TModel;
 }
 type AnyModel = Model<Record<string, unknown>, "id">;
+type RelatedRef<TRelated extends object, RelatedKey extends keyof TRelated & string> = RelatedModelClass<TRelated, RelatedKey> | string | (() => RelatedModelClass<TRelated, RelatedKey>);
 type ModelObserver = {
+    retrieved?: (model: AnyModel) => unknown;
     creating?: (model: AnyModel) => unknown;
     created?: (model: AnyModel) => unknown;
     updating?: (model: AnyModel) => unknown;
     updated?: (model: AnyModel) => unknown;
+    saving?: (model: AnyModel) => unknown;
+    saved?: (model: AnyModel) => unknown;
     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;
 declare function filterMassAssignable(fillable: readonly string[] | undefined, guarded: readonly string[] | true | undefined, input: LoadedAttributes): LoadedAttributes;
 declare function applyCasts(values: LoadedAttributes, casts: ModelCasts, direction: "hydrate" | "dehydrate"): LoadedAttributes;
+declare class ModelQuery {
+    private readonly modelClass;
+    readonly query: RepositoryQuery<Record<string, unknown>, "id">;
+    private readonly eager;
+    constructor(modelClass: object, query: RepositoryQuery<Record<string, unknown>, "id">);
+    with(...relations: string[]): this;
+    where(input: QueryWhere<object> | ((builder: import("./whereBuilder.ts").WhereBuilder<object>) => void)): this;
+    orWhere(input: QueryWhere<object> | ((builder: import("./whereBuilder.ts").WhereBuilder<object>) => void)): this;
+    orderBy(orderBy: QueryOptions<object>["orderBy"]): this;
+    limit(limit: number): this;
+    offset(offset: number): this;
+    whereNull(column: string): this;
+    whereIn(column: string, values: readonly unknown[]): this;
+    whereExists(sql: string, params?: readonly unknown[]): this;
+    whereNotExists(sql: string, params?: readonly unknown[]): this;
+    whereHas(name: string, constrain?: (query: AnyRelationQuery) => void): this;
+    has(name: string): this;
+    doesntHave(name: string): this;
+    whereDoesntHave(name: string, constrain?: (query: AnyRelationQuery) => void): this;
+    withHasMany(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withHasMany"]>): this;
+    withBelongsTo(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withBelongsTo"]>): this;
+    withBelongsToMany(...args: Parameters<RepositoryQuery<Record<string, unknown>, "id">["withBelongsToMany"]>): this;
+    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;
+    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>;
+    findOrFail(id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
+    then(onfulfilled?: ((value: Array<Model<Record<string, unknown>, "id">>) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
+    private constrainExists;
+}
 declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
     protected attributes: TEntity;
     protected readonly repository: BaseRepository<TEntity, PrimaryKey>;
@@ -35,6 +73,7 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     static $hidden?: readonly string[];
     static $visible?: readonly string[];
     static $appends?: readonly string[];
+    static $morphClass?: string;
     private _exists;
     private readonly loadedRelations;
     private hiddenOverrides;
@@ -60,21 +99,18 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     static observe(this: object, observer: ModelObserver): void;
     static addGlobalScope<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, _name: string, scope: GlobalScopeFn<TEntity, PrimaryKey>): void;
     static repository<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object): BaseRepository<TEntity, PrimaryKey>;
-    static query<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object): RepositoryQuery<TEntity, PrimaryKey>;
+    static query(this: object): ModelQuery;
     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[]): {
-        get(): Promise<Array<Model<Record<string, unknown>, "id">>>;
-        first(): Promise<Model<Record<string, unknown>, "id"> | null>;
-    };
-    static whereHas(this: object, name: string, constrain?: (query: AnyRelationQuery) => void): RepositoryQuery<Record<string, unknown>, "id">;
-    static has(this: object, name: string): RepositoryQuery<Record<string, unknown>, "id">;
-    static doesntHave(this: object, name: string): RepositoryQuery<Record<string, unknown>, "id">;
-    static whereDoesntHave(this: object, name: string, constrain?: (query: AnyRelationQuery) => void): RepositoryQuery<Record<string, unknown>, "id">;
+    static with(this: object, ...relations: string[]): ModelQuery;
+    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;
+    static whereDoesntHave(this: object, name: string, constrain?: (query: AnyRelationQuery) => void): ModelQuery;
     static find(this: object, id: unknown): Promise<Model<Record<string, unknown>, "id"> | null>;
     static findOrFail(this: object, id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
     static all(this: object, options?: Omit<QueryOptions<object>, "where">): Promise<Array<Model<Record<string, unknown>, "id">>>;
-    static where(this: object, where: QueryWhere<object>): RepositoryQuery<Record<string, unknown>, "id">;
+    static where(this: object, where: QueryWhere<object>): ModelQuery;
     static firstWhere(this: object, where: QueryWhere<object>, options?: Omit<QueryOptions<object>, "where">): Promise<Model<Record<string, unknown>, "id"> | null>;
     static firstOrNew(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
     static firstOrCreate(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
@@ -88,19 +124,20 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     loadHasOne<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasOneRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): Promise<this & Record<Alias, TChild | undefined>>;
     loadBelongsTo<TParent extends object, ForeignKey extends keyof TEntity & string, OwnerKey extends keyof TParent & string, Alias extends string>(as: Alias, relation: BelongsToRelation<TEntity, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<this & Record<Alias, TParent | undefined>>;
     loadBelongsToMany<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">): Promise<this & Record<Alias, TRelated[]>>;
-    hasMany<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedModelClass<TRelated, RelatedKey>, foreignKey?: keyof TRelated & string, localKey?: PrimaryKey): HasManyRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
-    hasOne<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedModelClass<TRelated, RelatedKey>, foreignKey?: keyof TRelated & string, localKey?: PrimaryKey): HasOneRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
-    belongsTo<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedModelClass<TRelated, RelatedKey>, foreignKey?: keyof TEntity & string, ownerKey?: RelatedKey): BelongsToRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
-    belongsToMany<TRelated extends object, RelatedKey extends keyof TRelated & string, Pivot extends object = Record<string, unknown>>(related: RelatedModelClass<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: RelatedModelClass<TRelated, RelatedKey>, morphName: string, typeKey?: keyof TRelated & string, idKey?: keyof TRelated & string): MorphManyRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
-    morphOne<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedModelClass<TRelated, RelatedKey>, morphName: string, typeKey?: keyof TRelated & string, idKey?: keyof TRelated & string): MorphOneRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
-    morphTo(relatedByType: Record<string, RelatedModelClass<Record<string, unknown>, "id">>, morphName?: string, typeKey?: keyof TEntity & string, idKey?: keyof TEntity & string): MorphToRelationQuery<TEntity, PrimaryKey>;
+    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>;
+    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>;
+    morphTo(relatedByType: Record<string, RelatedRef<Record<string, unknown>, "id">>, morphName?: string, typeKey?: keyof TEntity & string, idKey?: keyof TEntity & string): MorphToRelationQuery<TEntity, PrimaryKey>;
     load(...names: string[]): Promise<this>;
     loaded<T = unknown>(name: string): T | undefined;
     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 type { CastType, GlobalScopeFn, ModelClassType, ModelConstructor };
-export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, };
+export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, ModelQuery, registerModelClass, registerModelRepository, };

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

@@ -40,7 +40,12 @@ declare class HasManyRelationQuery<TParent extends object, ParentKey extends key
     get(): Promise<RelatedRecord[]>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
+    then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
+    save(related: RelatedRecord | (Record<string, unknown> & {
+        save?: () => Promise<unknown>;
+        mergeAttributes?: (patch: Record<string, unknown>) => unknown;
+    })): Promise<RelatedRecord>;
     createMany(records: ReadonlyArray<Record<string, unknown>>): Promise<RelatedRecord[]>;
 }
 declare class HasOneRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TChild extends object, ChildKey extends keyof TChild & string> {
@@ -56,21 +61,26 @@ declare class HasOneRelationQuery<TParent extends object, ParentKey extends keyo
     get(): Promise<RelatedRecord | null>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
+    then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
+    save(related: RelatedRecord | Record<string, unknown>): Promise<RelatedRecord>;
 }
 declare class BelongsToRelationQuery<TChild extends object, ChildKey extends keyof TChild & string, TParent extends object, ParentKey extends keyof TParent & string> {
     private readonly parent;
     private readonly related;
     readonly relation: BelongsToRelation<TChild, TParent, keyof TChild & string, ParentKey>;
     readonly kind: RelationKind;
+    private extraWhere;
     private extraOptions;
     constructor(parent: RelationHost<TChild, ChildKey>, related: RelatedModelClass<TParent, ParentKey>, relation: BelongsToRelation<TChild, TParent, keyof TChild & string, ParentKey>);
+    where(where: QueryWhere<TParent>): this;
     orderBy(orderBy: QueryOptions<TParent>["orderBy"]): this;
     applyEagerLoad(query: RepositoryQuery<TChild, ChildKey>, alias: string): void;
     hydrateEager(row: Record<string, unknown>, alias: string): unknown;
     toExistsClause(parentTable: string): ExistsClause;
     get(): Promise<RelatedRecord | null>;
     first(): Promise<RelatedRecord | null>;
+    then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     associate(owner: {
         id?: unknown;
     } | RelatedRecord): Promise<void>;
@@ -83,17 +93,21 @@ declare class BelongsToManyRelationQuery<TParent extends object, ParentKey exten
     readonly kind: RelationKind;
     private extraWhere;
     private extraOptions;
+    private pivotValues;
     constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TRelated, RelatedKey>, relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, keyof Pivot & string, keyof Pivot & string>);
     where(where: QueryWhere<TRelated>): this;
     orderBy(orderBy: QueryOptions<TRelated>["orderBy"]): this;
-    applyEagerLoad(_query: RepositoryQuery<TParent, ParentKey>, _alias: string): void;
+    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
+    withPivotValues(values: Record<string, unknown>): this;
     hydrateEager(row: Record<string, unknown>, alias: string): unknown;
     toExistsClause(parentTable: string): ExistsClause;
     private connection;
     get(): Promise<RelatedRecord[]>;
     first(): Promise<RelatedRecord | null>;
     count(): Promise<number>;
+    then(onfulfilled?: ((value: RelatedRecord[]) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     attach(ids: unknown | readonly unknown[]): Promise<void>;
+    toggle(ids: unknown | readonly unknown[]): Promise<void>;
     detach(ids?: unknown | readonly unknown[]): Promise<void>;
     sync(ids: readonly unknown[]): Promise<void>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
@@ -112,6 +126,8 @@ declare class MorphManyRelationQuery<TParent extends object, ParentKey extends k
     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>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
 }
 declare class MorphOneRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TChild extends object, ChildKey extends keyof TChild & string> {
@@ -124,6 +140,9 @@ declare class MorphOneRelationQuery<TParent extends object, ParentKey extends ke
     hydrateEager(row: Record<string, unknown>, alias: string): unknown;
     toExistsClause(parentTable: string): ExistsClause;
     get(): Promise<RelatedRecord | null>;
+    first(): Promise<RelatedRecord | null>;
+    count(): Promise<number>;
+    then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
     create(attributes?: Record<string, unknown>): Promise<RelatedRecord>;
 }
 declare class MorphToRelationQuery<TChild extends object, ChildKey extends keyof TChild & string> {
@@ -131,11 +150,14 @@ declare class MorphToRelationQuery<TChild extends object, ChildKey extends keyof
     private readonly relatedByType;
     readonly relation: MorphToRelation<TChild, keyof TChild & string, keyof TChild & string>;
     readonly kind: RelationKind;
+    private extraWhere;
     constructor(parent: RelationHost<TChild, ChildKey>, relatedByType: Record<string, RelatedModelClass<Record<string, unknown>, "id">>, relation: MorphToRelation<TChild, keyof TChild & string, keyof TChild & string>);
+    where(where: QueryWhere<Record<string, unknown>>): this;
     applyEagerLoad(query: RepositoryQuery<TChild, ChildKey>, alias: string): void;
     hydrateEager(row: Record<string, unknown>, alias: string): unknown;
     toExistsClause(parentTable: string): ExistsClause;
     get(): Promise<RelatedRecord | null>;
+    then(onfulfilled?: ((value: RelatedRecord | null) => unknown) | null, onrejected?: ((reason: unknown) => unknown) | null): Promise<unknown>;
 }
 type AnyRelationQuery = {
     kind: RelationKind;
@@ -144,6 +166,7 @@ type AnyRelationQuery = {
     get(): Promise<unknown>;
     toExistsClause(parentTable: string): ExistsClause;
     where?(where: Record<string, unknown>): unknown;
+    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, };

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

@@ -48,6 +48,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 +97,6 @@ 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>;
+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, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, };
+export { belongsTo, belongsToMany, getByRelationKey, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, 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 { BelongsToRelation, HasManyRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
+import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
 import type { QueryOptions, QueryWhere } from "./types.ts";
 import { WhereBuilder } from "./whereBuilder.ts";
 type LoadedRow = Record<string, unknown>;
@@ -30,8 +30,11 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     withMorphMany<TChild extends object, LocalKey extends keyof TEntity & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: MorphManyRelation<TEntity, TChild, LocalKey, MorphTypeKey, MorphIdKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
     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;
     get(): Promise<Array<TEntity & LoadedRow>>;
     first(): Promise<(TEntity & LoadedRow) | null>;
+    count(): Promise<number>;
+    attachToRows(rows: readonly TEntity[]): Promise<Array<TEntity & LoadedRow>>;
     paginate(options: {
         page: number;
         perPage: number;

package/dist/core/http/resources.d.ts

@@ -5,7 +5,7 @@ declare function whenLoaded<T>(model: {
 declare class JsonResource<T = unknown> {
     protected readonly resource: T;
     static wrap: string | null;
-    private extra;
+    protected extra: Record<string, unknown>;
     constructor(resource: T);
     static make<TResource>(resource: TResource): JsonResource<TResource>;
     static collection<TResource>(items: readonly TResource[]): ResourceCollection<TResource>;
@@ -17,6 +17,7 @@ declare class JsonResource<T = unknown> {
 }
 declare class ResourceCollection<T> extends JsonResource<readonly T[]> {
     toArray(): Record<string, unknown>;
+    toResponse(): Record<string, unknown>;
 }
 declare function toResourceCollection<TInput, TOutput>(items: readonly TInput[], transformer: (item: TInput) => TOutput): TOutput[];
 declare function toPaginatedResourceCollection<TInput, TOutput, TMeta extends object>(items: readonly TInput[], meta: TMeta, transformer: (item: TInput) => TOutput): {

package/dist/entries/database/factory.js

@@ -1,5 +1,38 @@
 // @bun
+// ../../src/core/database/inflection.ts
+function singularize(word) {
+  if (word.endsWith("ies") && word.length > 3) {
+    return `${word.slice(0, -3)}y`;
+  }
+  if (/(ses|xes|zes|ches|shes)$/i.test(word)) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && !word.endsWith("ss")) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function foreignKeyFromTable(tableName) {
+  return `${singularize(tableName)}_id`;
+}
+function pivotTableName(leftTable, rightTable) {
+  return [singularize(leftTable), singularize(rightTable)].sort().join("_");
+}
+
 // ../../src/core/database/factory.ts
+function inferFactoryForeignKey(parent, explicit) {
+  if (explicit) {
+    if (explicit.endsWith("_id")) {
+      return explicit;
+    }
+    return `${explicit}_id`;
+  }
+  if (typeof parent.getRepository === "function") {
+    return foreignKeyFromTable(parent.getRepository().getTable().name);
+  }
+  throw new Error("Factory.for() requires a foreign key or a parent Model.");
+}
+
 class Factory {
   quantity = 1;
   counted = false;
@@ -10,6 +43,7 @@ class Factory {
   children = [];
   afterMakingCallbacks = [];
   afterCreatingCallbacks = [];
+  model;
   definition() {
     throw new Error("Factory definition must be implemented by subclass.");
   }
@@ -50,8 +84,9 @@ class Factory {
     if (parent.id === undefined || parent.id === null) {
       throw new Error("Factory.for() requires a parent with an id.");
     }
+    const key = inferFactoryForeignKey(parent, foreignKey);
     const next = this.clone();
-    next.parentAssociations = [...this.parentAssociations, { foreignKey, value: parent.id }];
+    next.parentAssociations = [...this.parentAssociations, { foreignKey: key, value: parent.id }];
     return next;
   }
   recycle(parent, foreignKey) {
@@ -132,7 +167,14 @@ class Factory {
     }
     return values;
   }
-  persist(_values) {
+  async persist(values) {
+    if (this.model) {
+      const created = await this.model.create(values);
+      if (created && typeof created.toObject === "function") {
+        return created.toObject();
+      }
+      return created;
+    }
     throw new Error("Factory.persist() must be implemented to use create().");
   }
 }