@getstrata/core 0.5.97 → 0.5.99

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @getstrata/core changelog
 
+## 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.
+- Model `$hidden`/`$visible`/`$appends`, `toArray()`/`toJSON()`, `makeHidden`/`makeVisible`/`append`, and `observe()`.
+- `Model.where()`, `firstOrNew()`, `firstOrCreate()`, and `updateOrCreate()`.
+- Factory `count`/`state`/`sequence`/`for`/`has`/`recycle` plus `afterMaking`/`afterCreating`.
+- `JsonResource` (`wrap`, `whenLoaded`, `additional`, `collection`).
+- Laravel aliases: container `make`/`instance`, EventBus `on`/`emit`, query `whereNull`/`whereIn`/`whereExists`.
+- Parity audit reports design score separately. Horizon/Nova/CLI stay Bun-native stand-ins.
+
 ## 0.5.97
 
 - `mapDatabaseError()` recognizes HTTP errors by `status` + `message`, not only `instanceof HttpError`. Subpath builds duplicate the class, so a thrown `ForbiddenError` was remapped to `400 Bad Request`.

package/dist/core/contracts/container.d.ts

@@ -12,6 +12,8 @@ declare class ServiceContainer implements ServiceContainerLike {
     bind<T>(key: string, factory: ServiceFactory<T>): void;
     get<T>(key: string): T;
     resolve<T>(key: string): T;
+    make<T>(key: string): T;
+    instance<T>(key: string, value: T): T;
     has(key: string): boolean;
 }
 interface ConfigStoreLike {

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

@@ -1,9 +1,51 @@
-declare class Factory<TRecord extends object> {
-    constructor();
+type FactoryState<TRecord extends object> = Partial<TRecord> | ((record: TRecord) => Partial<TRecord>);
+type FactorySequence<TRecord extends object> = Partial<TRecord> | ((index: number) => Partial<TRecord>);
+type FactoryMakeResult<TRecord extends object, Counted extends boolean> = Counted extends true ? TRecord[] : TRecord;
+declare class Factory<TRecord extends object, Counted extends boolean = false> {
+    private quantity;
+    private counted;
+    private sequenceIndex;
+    private stateTransforms;
+    private sequenceItems;
+    private parentAssociations;
+    private children;
+    private afterMakingCallbacks;
+    private afterCreatingCallbacks;
+    protected model?: {
+        create(attributes: Record<string, unknown>): Promise<{
+            toObject(): object;
+        }>;
+    };
     protected definition(): TRecord;
-    make(overrides?: Partial<TRecord>): TRecord;
-    create(overrides?: Partial<TRecord>): Promise<TRecord>;
+    protected clone(): this;
+    count(quantity: number): Factory<TRecord, true>;
+    state(state: FactoryState<TRecord>): Factory<TRecord, Counted>;
+    sequence(...items: Array<FactorySequence<TRecord>>): Factory<TRecord, Counted>;
+    for(parent: {
+        id?: unknown;
+        getRepository?: () => {
+            getTable(): {
+                name: string;
+            };
+        };
+    }, foreignKey?: keyof TRecord & string): Factory<TRecord, Counted>;
+    recycle(parent: {
+        id?: unknown;
+        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>;
+    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

@@ -2,8 +2,10 @@ export type { DatabaseConnection } from "./baseRepository.ts";
 export { default as BaseRepository } from "./baseRepository.ts";
 export { createDatabaseConnection } from "./connection.ts";
 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, dehydrateValue, filterMassAssignable, hydrateValue, Model, 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/inflection.d.ts

@@ -0,0 +1,4 @@
+declare function singularize(word: string): string;
+declare function foreignKeyFromTable(tableName: string): string;
+declare function pivotTableName(leftTable: string, rightTable: string): string;
+export { foreignKeyFromTable, pivotTableName, singularize };

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

@@ -1,8 +1,10 @@
 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 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>;
@@ -10,10 +12,56 @@ type ModelClassType<TEntity extends object, PrimaryKey extends keyof TEntity & s
 interface ModelConstructor<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>> extends ModelClassType<TEntity, PrimaryKey> {
     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;
+};
+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>;
@@ -21,26 +69,51 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     static $guarded?: readonly string[] | true;
     static $casts: ModelCasts;
     static $timestamps: boolean;
+    static $hidden?: readonly string[];
+    static $visible?: readonly string[];
+    static $appends?: readonly string[];
+    static $morphClass?: string;
     private _exists;
+    private readonly loadedRelations;
+    private hiddenOverrides;
+    private visibleOverrides;
+    private appended;
     constructor(attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean);
+    getRepository(): BaseRepository<TEntity, PrimaryKey>;
     get $exists(): boolean;
     get<K extends keyof TEntity>(key: K): TEntity[K];
     get id(): TEntity[PrimaryKey];
     toObject(): TEntity;
+    toArray(): Record<string, unknown>;
+    toJSON(): Record<string, unknown>;
+    makeHidden(...keys: string[]): this;
+    makeVisible(...keys: string[]): this;
+    append(...keys: string[]): this;
     protected primaryKey(): PrimaryKey;
     protected static primaryKeyField(this: object): string;
     protected static hydrateAttributes<TEntity extends object>(this: object, attributes: TEntity): TEntity;
     protected static dehydrateAttributes(this: object, attributes: LoadedAttributes): LoadedAttributes;
     protected static fromRecord<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, record: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): Model<TEntity, PrimaryKey>;
     static boot(): void;
+    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 create(this: object, attributes: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
+    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[]): 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>): 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">>;
+    static updateOrCreate(this: object, where: QueryWhere<object>, values?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
     save(): Promise<this>;
     update(changes: Partial<TEntity>): Promise<this>;
     delete(): Promise<boolean>;
@@ -50,8 +123,19 @@ 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: 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;
 }
 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

@@ -0,0 +1,172 @@
+import type BaseRepository from "./baseRepository.ts";
+import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
+import type { RepositoryQuery } from "./repositoryQuery.ts";
+import type { QueryOptions, QueryWhere } from "./types.ts";
+type RelatedRecord = {
+    id: unknown;
+    get<K extends string>(key: K): unknown;
+};
+interface RelatedModelClass<TRelated extends object, RelatedKey extends keyof TRelated & string> {
+    name: string;
+    repository(): BaseRepository<TRelated, RelatedKey>;
+    create(attributes: Record<string, unknown>, forced?: Record<string, unknown>): Promise<RelatedRecord>;
+    newFromRecord(record: TRelated, exists?: boolean): RelatedRecord;
+}
+interface RelationHost<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
+    readonly id: TEntity[PrimaryKey];
+    get<K extends keyof TEntity>(key: K): TEntity[K];
+    getRepository(): BaseRepository<TEntity, PrimaryKey>;
+}
+type RelationKind = "hasMany" | "hasOne" | "belongsTo" | "belongsToMany" | "morphMany" | "morphOne" | "morphTo";
+type ExistsClause = {
+    sql: string;
+    params: unknown[];
+};
+declare class HasManyRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TChild extends object, ChildKey extends keyof TChild & string> {
+    private readonly parent;
+    private readonly related;
+    readonly relation: HasManyRelation<TParent, TChild, ParentKey, keyof TChild & string>;
+    readonly kind: RelationKind;
+    private extraWhere;
+    private extraOptions;
+    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TChild, ChildKey>, relation: HasManyRelation<TParent, TChild, ParentKey, keyof TChild & string>);
+    where(where: QueryWhere<TChild>): this;
+    orderBy(orderBy: QueryOptions<TChild>["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;
+    private scopedQuery;
+    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> {
+    readonly relation: HasOneRelation<TParent, TChild, ParentKey, keyof TChild & string>;
+    readonly kind: RelationKind;
+    private readonly inner;
+    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TChild, ChildKey>, relation: HasOneRelation<TParent, TChild, ParentKey, keyof TChild & string>);
+    where(where: QueryWhere<TChild>): this;
+    orderBy(orderBy: QueryOptions<TChild>["orderBy"]): this;
+    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
+    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>;
+    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>;
+    dissociate(): Promise<void>;
+}
+declare class BelongsToManyRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TRelated extends object, RelatedKey extends keyof TRelated & string, Pivot extends object> {
+    private readonly parent;
+    private readonly related;
+    readonly relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, keyof Pivot & string, keyof Pivot & string>;
+    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;
+    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>;
+}
+declare class MorphManyRelationQuery<TParent extends object, ParentKey extends keyof TParent & string, TChild extends object, ChildKey extends keyof TChild & string> {
+    private readonly parent;
+    private readonly related;
+    readonly relation: MorphManyRelation<TParent, TChild, ParentKey, keyof TChild & string, keyof TChild & string>;
+    readonly kind: RelationKind;
+    private extraWhere;
+    private extraOptions;
+    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TChild, ChildKey>, relation: MorphManyRelation<TParent, TChild, ParentKey, keyof TChild & string, keyof TChild & string>);
+    where(where: QueryWhere<TChild>): 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>;
+    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> {
+    readonly relation: MorphOneRelation<TParent, TChild, ParentKey, keyof TChild & string, keyof TChild & string>;
+    readonly kind: RelationKind;
+    private readonly inner;
+    constructor(parent: RelationHost<TParent, ParentKey>, related: RelatedModelClass<TChild, ChildKey>, relation: MorphOneRelation<TParent, TChild, ParentKey, keyof TChild & string, keyof TChild & string>);
+    where(where: QueryWhere<TChild>): this;
+    applyEagerLoad(query: RepositoryQuery<TParent, ParentKey>, alias: string): void;
+    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> {
+    private readonly parent;
+    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;
+    applyEagerLoad(query: unknown, alias: string): void;
+    hydrateEager(row: Record<string, unknown>, alias: string): unknown;
+    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/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>;
@@ -15,6 +15,11 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     orWhere(input: QueryWhere<TEntity> | ((builder: WhereBuilder<TEntity>) => void)): this;
     orderBy(orderBy: QueryOptions<TEntity>["orderBy"]): this;
     limit(limit: number): this;
+    whereNull(column: keyof TEntity & string): this;
+    whereNotNull(column: keyof TEntity & string): this;
+    whereIn(column: keyof TEntity & string, values: readonly unknown[]): this;
+    whereExists(sql: string, params?: readonly unknown[]): this;
+    whereNotExists(sql: string, params?: readonly unknown[]): this;
     offset(offset: number): this;
     join(left: `${string}.${string}`, right: `${string}.${string}`): this;
     leftJoin(left: `${string}.${string}`, right: `${string}.${string}`): this;
@@ -25,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/database/whereBuilder.d.ts

@@ -1,10 +1,18 @@
 import type { QueryWhere } from "./types.ts";
+type ExistsClause = {
+    sql: string;
+    params: readonly unknown[];
+    not?: boolean;
+};
 type WhereNode<TEntity extends object> = {
     kind: "and" | "or";
     where: QueryWhere<TEntity>;
 } | {
     kind: "and" | "or";
     group: WhereNode<TEntity>[];
+} | {
+    kind: "and" | "or";
+    exists: ExistsClause;
 };
 declare class WhereBuilder<TEntity extends object> {
     readonly nodes: WhereNode<TEntity>[];
@@ -13,5 +21,5 @@ declare class WhereBuilder<TEntity extends object> {
     whereGroup(fn: (builder: WhereBuilder<TEntity>) => void): this;
     orWhereGroup(fn: (builder: WhereBuilder<TEntity>) => void): this;
 }
-export type { WhereNode };
+export type { ExistsClause, WhereNode };
 export { WhereBuilder };

package/dist/core/events/eventBus.d.ts

@@ -2,7 +2,9 @@ type EventListener = (payload: unknown) => void | Promise<void>;
 declare class EventBus {
     constructor();
     private readonly listeners;
+    on(event: string, listener: EventListener): () => void;
     listen(event: string, listener: EventListener): () => void;
+    emit(event: string, payload: unknown): Promise<void>;
     dispatch(event: string, payload: unknown): Promise<void>;
 }
 declare function readSharedEventBus(): EventBus;

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

@@ -1,7 +1,27 @@
 declare function serializeDate(value: Date | string): string;
+declare function whenLoaded<T>(model: {
+    loaded: (name: string) => unknown;
+}, relation: string, transform?: (value: unknown) => T): T | undefined;
+declare class JsonResource<T = unknown> {
+    protected readonly resource: T;
+    static wrap: string | null;
+    protected extra: Record<string, unknown>;
+    constructor(resource: T);
+    static make<TResource>(resource: TResource): JsonResource<TResource>;
+    static collection<TResource>(items: readonly TResource[]): ResourceCollection<TResource>;
+    additional(data: Record<string, unknown>): this;
+    when<TValue>(condition: boolean, value: TValue): TValue | undefined;
+    whenLoaded<TValue = unknown>(relation: string, transform?: (value: unknown) => TValue): TValue | undefined;
+    toArray(): Record<string, unknown>;
+    toResponse(): Record<string, 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): {
     data: TOutput[];
     meta: TMeta;
 };
-export { serializeDate, toPaginatedResourceCollection, toResourceCollection };
+export { JsonResource, ResourceCollection, serializeDate, toPaginatedResourceCollection, toResourceCollection, whenLoaded, };

package/dist/entries/contracts/container.js

@@ -39,6 +39,12 @@ class ServiceContainer {
   resolve(key) {
     return this.get(key);
   }
+  make(key) {
+    return this.resolve(key);
+  }
+  instance(key, value) {
+    return this.set(key, value);
+  }
   has(key) {
     return this.services.has(key) || this.singletonFactories.has(key) || this.bindings.has(key);
   }