@bunnykit/orm 0.1.0

package/dist/src/model/Model.d.ts

@@ -0,0 +1,166 @@
+import { Connection } from "../connection/Connection.js";
+import { Builder } from "../query/Builder.js";
+import { MorphTo, MorphOne, MorphMany, MorphToMany } from "./MorphRelations.js";
+import { BelongsToMany } from "./BelongsToMany.js";
+export type ModelConstructor<T extends Model = Model> = typeof Model & (new (...args: any[]) => T);
+export type GlobalScope = (builder: Builder<any>, model: typeof Model) => void;
+export type CastDefinition = string | CastsAttributes | (new (...args: any[]) => CastsAttributes);
+export interface CastsAttributes {
+    get(model: Model, key: string, value: any, attributes: Record<string, any>): any;
+    set(model: Model, key: string, value: any, attributes: Record<string, any>): any;
+}
+export declare abstract class Relation<T extends Model = Model> {
+    protected builder: Builder<T>;
+    protected parent: Model;
+    protected related: typeof Model;
+    protected foreignKey: string;
+    protected localKey: string;
+    constructor(parent: Model, related: typeof Model, foreignKey?: string, localKey?: string);
+    abstract addConstraints(): void;
+    abstract getResults(): Promise<T | T[] | null>;
+    abstract addEagerConstraints(models: Model[]): void;
+    abstract getEager(): Promise<any[]>;
+    abstract match(models: Model[], results: any[], relationName: string): void;
+    protected defaultForeignKey(): string;
+    getQuery(): Builder<T>;
+    qualifyRelatedColumn(column: string): string;
+    protected newExistenceQuery(parentQuery: Builder<any>, aggregate: string, callback?: (query: Builder<any>) => void | Builder<any>): Builder<any>;
+    getRelationExistenceSql(parentQuery: Builder<any>, callback?: (query: Builder<any>) => void | Builder<any>): string;
+    getRelationCountSql(parentQuery: Builder<any>, callback?: (query: Builder<any>) => void | Builder<any>): string;
+    getRelationAggregateSql(parentQuery: Builder<any>, aggregate: string, callback?: (query: Builder<any>) => void | Builder<any>): string;
+}
+export declare class HasMany<T extends Model = Model> extends Relation<T> {
+    constructor(parent: Model, related: typeof Model, foreignKey?: string, localKey?: string);
+    addConstraints(): void;
+    addEagerConstraints(models: Model[]): void;
+    getEager(): Promise<any[]>;
+    match(models: Model[], results: any[], relationName: string): void;
+    getResults(): Promise<T[]>;
+    latestOfMany(column?: string): HasOne<T>;
+    oldestOfMany(column?: string): HasOne<T>;
+    ofMany(column: string, aggregate?: "max" | "min"): HasOne<T>;
+}
+export declare class BelongsTo<T extends Model = Model> extends Relation<T> {
+    constructor(parent: Model, related: typeof Model, foreignKey?: string, ownerKey?: string);
+    addConstraints(): void;
+    addEagerConstraints(models: Model[]): void;
+    getEager(): Promise<any[]>;
+    match(models: Model[], results: any[], relationName: string): void;
+    getResults(): Promise<T | null>;
+    associate(model: Model | any): Model;
+    dissociate(): Model;
+    protected newExistenceQuery(parentQuery: Builder<any>, aggregate: string, callback?: (query: Builder<any>) => void | Builder<any>): Builder<any>;
+}
+export declare class HasManyThrough<T extends Model = Model> extends Relation<T> {
+    protected through: typeof Model;
+    protected firstKey: string;
+    protected secondKey: string;
+    protected secondLocalKey: string;
+    constructor(parent: Model, related: typeof Model, through: typeof Model, firstKey?: string, secondKey?: string, localKey?: string, secondLocalKey?: string);
+    addConstraints(): void;
+    addEagerConstraints(models: Model[]): void;
+    getEager(): Promise<any[]>;
+    match(models: Model[], results: any[], relationName: string): void;
+    getResults(): Promise<T[] | T | null>;
+    protected newExistenceQuery(parentQuery: Builder<any>, aggregate: string, callback?: (query: Builder<any>) => void | Builder<any>): Builder<any>;
+}
+export declare class HasOneThrough<T extends Model = Model> extends HasManyThrough<T> {
+    getResults(): Promise<T | null>;
+    match(models: Model[], results: any[], relationName: string): void;
+}
+export declare class HasOne<T extends Model = Model> extends Relation<T> {
+    constructor(parent: Model, related: typeof Model, foreignKey?: string, localKey?: string);
+    addConstraints(): void;
+    addEagerConstraints(models: Model[]): void;
+    getEager(): Promise<any[]>;
+    match(models: Model[], results: any[], relationName: string): void;
+    getResults(): Promise<T | null>;
+}
+export declare class Model<T extends Record<string, any> = Record<string, any>> {
+    static table: string;
+    static primaryKey: string;
+    static timestamps: boolean;
+    static connection?: Connection;
+    static dateFormat: string;
+    static morphName?: string;
+    static casts: Record<string, CastDefinition>;
+    static fillable: string[];
+    static guarded: string[];
+    static attributes: Record<string, any>;
+    static softDeletes: boolean;
+    static deletedAtColumn: string;
+    $attributes: T;
+    $original: Partial<T>;
+    $exists: boolean;
+    $relations: Record<string, any>;
+    $casts: Record<string, CastDefinition>;
+    constructor(attributes?: Partial<T>);
+    static getTable(): string;
+    static getConnection(): Connection;
+    static setConnection(connection: Connection): void;
+    static query<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
+    static addGlobalScope(name: string, scope: GlobalScope): void;
+    static removeGlobalScope(name: string): void;
+    static applyGlobalScopes(builder: Builder<any>): void;
+    static getQualifiedDeletedAtColumn(): string;
+    static create<M extends typeof Model>(this: M, attributes: Partial<InstanceType<M> extends Model<infer U> ? U : Record<string, any>>): Promise<InstanceType<M>>;
+    static find<M extends typeof Model>(this: M, id: any): Promise<InstanceType<M> | null>;
+    static first<M extends typeof Model>(this: M): Promise<InstanceType<M> | null>;
+    static where<M extends typeof Model>(this: M, column: string | Record<string, any>, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static whereIn<M extends typeof Model>(this: M, column: string, values: any[]): Builder<InstanceType<M>>;
+    static whereNull<M extends typeof Model>(this: M, column: string): Builder<InstanceType<M>>;
+    static whereNotNull<M extends typeof Model>(this: M, column: string): Builder<InstanceType<M>>;
+    static orWhere<M extends typeof Model>(this: M, column: string | Record<string, any>, operator?: string | any, value?: any): Builder<InstanceType<M>>;
+    static with<M extends typeof Model>(this: M, ...relations: string[]): Builder<InstanceType<M>>;
+    static withTrashed<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
+    static onlyTrashed<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
+    static withoutGlobalScope<M extends typeof Model>(this: M, scope: string): Builder<InstanceType<M>>;
+    static withoutGlobalScopes<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
+    static scope<M extends typeof Model>(this: M, name: string, ...args: any[]): Builder<InstanceType<M>>;
+    static has<M extends typeof Model>(this: M, relationName: string, operator?: string, count?: number): Builder<InstanceType<M>>;
+    static whereHas<M extends typeof Model>(this: M, relationName: string, callback?: (query: Builder<any>) => void | Builder<any>, operator?: string, count?: number): Builder<InstanceType<M>>;
+    static doesntHave<M extends typeof Model>(this: M, relationName: string): Builder<InstanceType<M>>;
+    static withCount<M extends typeof Model>(this: M, relationName: string, alias?: string): Builder<InstanceType<M>>;
+    static withSum<M extends typeof Model>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
+    static withAvg<M extends typeof Model>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
+    static withMin<M extends typeof Model>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
+    static withMax<M extends typeof Model>(this: M, relationName: string, column: string, alias?: string): Builder<InstanceType<M>>;
+    static all<M extends typeof Model>(this: M): Promise<InstanceType<M>[]>;
+    static paginate<M extends typeof Model>(this: M, perPage?: number, page?: number): Promise<import("../query/Builder.js").Paginator<InstanceType<M>>>;
+    static eagerLoadRelations(models: Model[], relations: string[]): Promise<void>;
+    static eagerLoadRelation(models: Model[], relationName: string): Promise<void>;
+    fill(attributes: Partial<T>): this;
+    isFillable(key: string): boolean;
+    getAttribute<K extends keyof T>(key: K): T[K];
+    getAttribute(key: string): any;
+    setAttribute<K extends keyof T>(key: K, value: T[K]): void;
+    setAttribute(key: string, value: any): void;
+    castAttribute(key: string, value: any): any;
+    serializeCastAttribute(key: string, value: any): any;
+    mergeCasts(casts: Record<string, CastDefinition>): this;
+    protected getCastDefinition(key: string): CastDefinition | undefined;
+    protected resolveCustomCast(cast: CastDefinition): CastsAttributes | null;
+    getDirty(): Partial<T>;
+    isDirty(): boolean;
+    save(): Promise<this>;
+    delete(): Promise<boolean>;
+    restore(): Promise<boolean>;
+    forceDelete(): Promise<boolean>;
+    refresh(): Promise<this>;
+    toJSON(): Record<string, any>;
+    toString(): string;
+    freshTimestamp(): string;
+    setRelation(name: string, value: any): void;
+    getRelation(name: string): any;
+    hasMany<R extends Model>(related: ModelConstructor<R>, foreignKey?: string, localKey?: string): HasMany<R>;
+    belongsTo<R extends Model>(related: ModelConstructor<R>, foreignKey?: string, ownerKey?: string): BelongsTo<R>;
+    hasOne<R extends Model>(related: ModelConstructor<R>, foreignKey?: string, localKey?: string): HasOne<R>;
+    hasManyThrough<R extends Model>(related: ModelConstructor<R>, through: ModelConstructor, firstKey?: string, secondKey?: string, localKey?: string, secondLocalKey?: string): HasManyThrough<R>;
+    hasOneThrough<R extends Model>(related: ModelConstructor<R>, through: ModelConstructor, firstKey?: string, secondKey?: string, localKey?: string, secondLocalKey?: string): HasOneThrough<R>;
+    belongsToMany<R extends Model>(related: ModelConstructor<R>, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): BelongsToMany<R>;
+    morphTo(name: string, typeMap?: Record<string, ModelConstructor>): MorphTo;
+    morphOne<R extends Model>(related: ModelConstructor<R>, name: string, typeColumn?: string, idColumn?: string, localKey?: string): MorphOne<R>;
+    morphMany<R extends Model>(related: ModelConstructor<R>, name: string, typeColumn?: string, idColumn?: string, localKey?: string): MorphMany<R>;
+    morphToMany<R extends Model>(related: ModelConstructor<R>, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): MorphToMany<R>;
+    morphedByMany<R extends Model>(related: ModelConstructor<R>, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): MorphToMany<R>;
+}