@bunnykit/orm 0.1.0

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

@@ -0,0 +1,7 @@
+import type { Model } from "./Model.js";
+export declare class MorphMap {
+    private static map;
+    static register(name: string, model: typeof Model): void;
+    static get(name: string): typeof Model | undefined;
+    static keys(): string[];
+}

package/dist/src/model/MorphMap.js

@@ -0,0 +1,12 @@
+export class MorphMap {
+    static map = new Map();
+    static register(name, model) {
+        this.map.set(name, model);
+    }
+    static get(name) {
+        return this.map.get(name);
+    }
+    static keys() {
+        return Array.from(this.map.keys());
+    }
+}

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

@@ -0,0 +1,81 @@
+import { Builder } from "../query/Builder.js";
+import type { Model, ModelConstructor } from "./Model.js";
+export declare class MorphTo<T extends Model = Model> {
+    protected parent: Model;
+    protected name: string;
+    protected typeColumn: string;
+    protected idColumn: string;
+    protected typeMap?: Record<string, ModelConstructor>;
+    constructor(parent: Model, name: string, typeMap?: Record<string, ModelConstructor>);
+    getResults(): Promise<T | null>;
+    private resolveAndFind;
+    addEagerConstraints(models: Model[]): void;
+    getEager(): Promise<any[]>;
+    match(models: Model[], _results: any[], relationName: string): void;
+}
+export declare class MorphOne<T extends Model = Model> {
+    protected builder: Builder<T>;
+    protected parent: Model;
+    protected related: typeof Model;
+    protected name: string;
+    protected typeColumn: string;
+    protected idColumn: string;
+    protected localKey: string;
+    constructor(parent: Model, related: typeof Model, name: string, typeColumn?: string, idColumn?: string, localKey?: string);
+    protected getMorphType(): string;
+    getQuery(): Builder<T>;
+    addEagerConstraints(models: Model[]): void;
+    getEager(): Promise<any[]>;
+    match(models: Model[], results: any[], relationName: string): void;
+    getResults(): Promise<T | null>;
+    qualifyRelatedColumn(column: string): string;
+    protected newExistenceQuery(parentTable: string, 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 MorphMany<T extends Model = Model> {
+    protected builder: Builder<T>;
+    protected parent: Model;
+    protected related: typeof Model;
+    protected name: string;
+    protected typeColumn: string;
+    protected idColumn: string;
+    protected localKey: string;
+    constructor(parent: Model, related: typeof Model, name: string, typeColumn?: string, idColumn?: string, localKey?: string);
+    protected getMorphType(): string;
+    getQuery(): Builder<T>;
+    addEagerConstraints(models: Model[]): void;
+    getEager(): Promise<any[]>;
+    match(models: Model[], results: any[], relationName: string): void;
+    getResults(): Promise<T[]>;
+    qualifyRelatedColumn(column: string): string;
+    protected newExistenceQuery(parentTable: string, 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 MorphToMany<T extends Model = Model> {
+    protected builder: Builder<T>;
+    protected parent: Model;
+    protected related: typeof Model;
+    protected name: string;
+    protected table: string;
+    protected foreignPivotKey: string;
+    protected relatedPivotKey: string;
+    protected parentKey: string;
+    protected relatedKey: string;
+    protected morphType: string;
+    constructor(parent: Model, related: typeof Model, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string, morphType?: string);
+    protected addConstraints(): void;
+    getQuery(): Builder<T>;
+    addEagerConstraints(models: Model[]): void;
+    getEager(): Promise<any[]>;
+    match(models: Model[], results: any[], relationName: string): void;
+    getResults(): Promise<T[]>;
+    qualifyRelatedColumn(column: string): string;
+    protected newExistenceQuery(parentTable: string, 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;
+}

package/dist/src/model/MorphRelations.js

@@ -0,0 +1,296 @@
+import { snakeCase } from "../utils.js";
+import { MorphMap } from "./MorphMap.js";
+export class MorphTo {
+    parent;
+    name;
+    typeColumn;
+    idColumn;
+    typeMap;
+    constructor(parent, name, typeMap) {
+        this.parent = parent;
+        this.name = name;
+        this.typeColumn = `${name}_type`;
+        this.idColumn = `${name}_id`;
+        this.typeMap = typeMap;
+    }
+    async getResults() {
+        const type = this.parent.getAttribute(this.typeColumn);
+        const id = this.parent.getAttribute(this.idColumn);
+        if (!type || !id)
+            return null;
+        return this.resolveAndFind(type, id);
+    }
+    async resolveAndFind(type, id) {
+        let Related;
+        if (this.typeMap) {
+            Related = this.typeMap[type];
+        }
+        if (!Related) {
+            Related = MorphMap.get(type);
+        }
+        if (!Related) {
+            throw new Error(`No morph mapping found for type: ${type}. Register it with MorphMap.register() or pass a typeMap.`);
+        }
+        return Related.find(id);
+    }
+    addEagerConstraints(models) {
+        // MorphTo eager loading is handled separately in getEager
+    }
+    async getEager() {
+        return []; // Results are assembled in match
+    }
+    match(models, _results, relationName) {
+        // Group models by type
+        const typeGroups = {};
+        for (const model of models) {
+            const type = model.getAttribute(this.typeColumn);
+            if (!type)
+                continue;
+            if (!typeGroups[type])
+                typeGroups[type] = [];
+            typeGroups[type].push(model);
+        }
+        // For each type, find the related models
+        for (const [type, groupModels] of Object.entries(typeGroups)) {
+            const ids = groupModels.map((m) => m.getAttribute(this.idColumn)).filter((id) => id !== null && id !== undefined);
+            if (ids.length === 0)
+                continue;
+            let Related;
+            if (this.typeMap)
+                Related = this.typeMap[type];
+            if (!Related)
+                Related = MorphMap.get(type);
+            if (!Related)
+                continue;
+            const relatedModels = Related.whereIn(Related.primaryKey, ids).get();
+            // We need to execute this synchronously-ish... but it's async
+            // Actually, we can't do async in for...of without awaiting
+        }
+    }
+}
+export class MorphOne {
+    builder;
+    parent;
+    related;
+    name;
+    typeColumn;
+    idColumn;
+    localKey;
+    constructor(parent, related, name, typeColumn, idColumn, localKey) {
+        this.parent = parent;
+        this.related = related;
+        this.name = name;
+        this.typeColumn = typeColumn || `${name}_type`;
+        this.idColumn = idColumn || `${name}_id`;
+        this.localKey = localKey || parent.constructor.primaryKey;
+        this.builder = related.query();
+        this.builder.where(this.typeColumn, this.getMorphType());
+        this.builder.where(this.idColumn, this.parent.getAttribute(this.localKey));
+    }
+    getMorphType() {
+        return this.parent.constructor.morphName || this.parent.constructor.name;
+    }
+    getQuery() {
+        return this.builder;
+    }
+    addEagerConstraints(models) {
+        this.builder = this.related.query();
+        const keys = models.map((m) => m.getAttribute(this.localKey));
+        this.builder.whereIn(this.idColumn, keys);
+        this.builder.where(this.typeColumn, this.getMorphType());
+    }
+    async getEager() {
+        return this.builder.get();
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.$attributes[this.idColumn];
+            dictionary[String(key)] = result;
+        }
+        for (const model of models) {
+            const key = model.getAttribute(this.localKey);
+            model.setRelation(relationName, dictionary[String(key)] || null);
+        }
+    }
+    async getResults() {
+        return this.builder.first();
+    }
+    qualifyRelatedColumn(column) {
+        return column.includes(".") ? column : `${this.related.getTable()}.${column}`;
+    }
+    newExistenceQuery(parentTable, aggregate, callback) {
+        const query = this.related.query().select(aggregate);
+        query.whereColumn(`${this.related.getTable()}.${this.idColumn}`, "=", `${parentTable}.${this.localKey}`);
+        query.where(`${this.related.getTable()}.${this.typeColumn}`, this.getMorphType());
+        if (callback)
+            callback(query);
+        return query;
+    }
+    getRelationExistenceSql(parentQuery, callback) {
+        return this.newExistenceQuery(parentQuery.tableName, "1", callback).toSql();
+    }
+    getRelationCountSql(parentQuery, callback) {
+        return this.getRelationAggregateSql(parentQuery, "COUNT(*)", callback);
+    }
+    getRelationAggregateSql(parentQuery, aggregate, callback) {
+        return this.newExistenceQuery(parentQuery.tableName, aggregate, callback).toSql();
+    }
+}
+export class MorphMany {
+    builder;
+    parent;
+    related;
+    name;
+    typeColumn;
+    idColumn;
+    localKey;
+    constructor(parent, related, name, typeColumn, idColumn, localKey) {
+        this.parent = parent;
+        this.related = related;
+        this.name = name;
+        this.typeColumn = typeColumn || `${name}_type`;
+        this.idColumn = idColumn || `${name}_id`;
+        this.localKey = localKey || parent.constructor.primaryKey;
+        this.builder = related.query();
+        this.builder.where(this.typeColumn, this.getMorphType());
+        this.builder.where(this.idColumn, this.parent.getAttribute(this.localKey));
+    }
+    getMorphType() {
+        return this.parent.constructor.morphName || this.parent.constructor.name;
+    }
+    getQuery() {
+        return this.builder;
+    }
+    addEagerConstraints(models) {
+        this.builder = this.related.query();
+        const keys = models.map((m) => m.getAttribute(this.localKey));
+        this.builder.whereIn(this.idColumn, keys);
+        this.builder.where(this.typeColumn, this.getMorphType());
+    }
+    async getEager() {
+        return this.builder.get();
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.$attributes[this.idColumn];
+            if (!dictionary[key])
+                dictionary[key] = [];
+            dictionary[key].push(result);
+        }
+        for (const model of models) {
+            const key = model.getAttribute(this.localKey);
+            model.setRelation(relationName, dictionary[String(key)] || []);
+        }
+    }
+    async getResults() {
+        return this.builder.get();
+    }
+    qualifyRelatedColumn(column) {
+        return column.includes(".") ? column : `${this.related.getTable()}.${column}`;
+    }
+    newExistenceQuery(parentTable, aggregate, callback) {
+        const query = this.related.query().select(aggregate);
+        query.whereColumn(`${this.related.getTable()}.${this.idColumn}`, "=", `${parentTable}.${this.localKey}`);
+        query.where(`${this.related.getTable()}.${this.typeColumn}`, this.getMorphType());
+        if (callback)
+            callback(query);
+        return query;
+    }
+    getRelationExistenceSql(parentQuery, callback) {
+        return this.newExistenceQuery(parentQuery.tableName, "1", callback).toSql();
+    }
+    getRelationCountSql(parentQuery, callback) {
+        return this.getRelationAggregateSql(parentQuery, "COUNT(*)", callback);
+    }
+    getRelationAggregateSql(parentQuery, aggregate, callback) {
+        return this.newExistenceQuery(parentQuery.tableName, aggregate, callback).toSql();
+    }
+}
+export class MorphToMany {
+    builder;
+    parent;
+    related;
+    name;
+    table;
+    foreignPivotKey;
+    relatedPivotKey;
+    parentKey;
+    relatedKey;
+    morphType;
+    constructor(parent, related, name, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey, morphType) {
+        this.parent = parent;
+        this.related = related;
+        this.name = name;
+        this.table = table || `${name}s`;
+        this.parentKey = parentKey || parent.constructor.primaryKey;
+        this.relatedKey = relatedKey || related.primaryKey;
+        this.morphType = morphType || parent.constructor.morphName || parent.constructor.name;
+        this.foreignPivotKey = foreignPivotKey || `${snakeCase(name)}_id`;
+        this.relatedPivotKey = relatedPivotKey || `${snakeCase(related.name)}_id`;
+        this.builder = related.query();
+        this.addConstraints();
+    }
+    addConstraints() {
+        const relatedTable = this.related.getTable();
+        this.builder.select(`${relatedTable}.*`);
+        this.builder.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
+        this.builder.where(`${this.table}.${this.foreignPivotKey}`, this.parent.getAttribute(this.parentKey));
+        this.builder.where(`${this.table}.${this.name}_type`, this.morphType);
+    }
+    getQuery() {
+        return this.builder;
+    }
+    addEagerConstraints(models) {
+        const keys = models.map((m) => m.getAttribute(this.parentKey));
+        const relatedTable = this.related.getTable();
+        this.builder = this.related.query();
+        this.builder.select(`${relatedTable}.*`, `${this.table}.${this.foreignPivotKey}`);
+        this.builder.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
+        this.builder.whereIn(`${this.table}.${this.foreignPivotKey}`, keys);
+        this.builder.where(`${this.table}.${this.name}_type`, this.morphType);
+    }
+    async getEager() {
+        return this.builder.get();
+    }
+    match(models, results, relationName) {
+        const dictionary = {};
+        for (const result of results) {
+            const key = result.$attributes[this.foreignPivotKey];
+            if (!dictionary[key])
+                dictionary[key] = [];
+            delete result.$attributes[this.foreignPivotKey];
+            dictionary[key].push(result);
+        }
+        for (const model of models) {
+            const key = model.getAttribute(this.parentKey);
+            model.setRelation(relationName, dictionary[String(key)] || []);
+        }
+    }
+    async getResults() {
+        return this.builder.get();
+    }
+    qualifyRelatedColumn(column) {
+        return column.includes(".") ? column : `${this.related.getTable()}.${column}`;
+    }
+    newExistenceQuery(parentTable, aggregate, callback) {
+        const relatedTable = this.related.getTable();
+        const query = this.related.query().select(aggregate);
+        query.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
+        query.whereColumn(`${this.table}.${this.foreignPivotKey}`, "=", `${parentTable}.${this.parentKey}`);
+        query.where(`${this.table}.${this.name}_type`, this.morphType);
+        if (callback)
+            callback(query);
+        return query;
+    }
+    getRelationExistenceSql(parentQuery, callback) {
+        return this.newExistenceQuery(parentQuery.tableName, "1", callback).toSql();
+    }
+    getRelationCountSql(parentQuery, callback) {
+        return this.getRelationAggregateSql(parentQuery, "COUNT(*)", callback);
+    }
+    getRelationAggregateSql(parentQuery, aggregate, callback) {
+        return this.newExistenceQuery(parentQuery.tableName, aggregate, callback).toSql();
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { Model } from "./Model.js";
+export interface ObserverContract<T extends Model = Model> {
+    creating?(model: T): Promise<void> | void;
+    created?(model: T): Promise<void> | void;
+    updating?(model: T): Promise<void> | void;
+    updated?(model: T): Promise<void> | void;
+    saving?(model: T): Promise<void> | void;
+    saved?(model: T): Promise<void> | void;
+    deleting?(model: T): Promise<void> | void;
+    deleted?(model: T): Promise<void> | void;
+    restoring?(model: T): Promise<void> | void;
+    restored?(model: T): Promise<void> | void;
+}
+export declare class ObserverRegistry {
+    private static observers;
+    static register(modelClass: typeof Model, observer: ObserverContract): void;
+    static get(modelClass: typeof Model): ObserverContract[];
+    static dispatch<T extends Model>(event: keyof ObserverContract, model: T): Promise<void>;
+}

package/dist/src/model/Observer.js

@@ -0,0 +1,21 @@
+export class ObserverRegistry {
+    static observers = new Map();
+    static register(modelClass, observer) {
+        if (!this.observers.has(modelClass)) {
+            this.observers.set(modelClass, []);
+        }
+        this.observers.get(modelClass).push(observer);
+    }
+    static get(modelClass) {
+        return this.observers.get(modelClass) || [];
+    }
+    static async dispatch(event, model) {
+        const observers = this.get(model.constructor);
+        for (const observer of observers) {
+            const handler = observer[event];
+            if (handler) {
+                await handler(model);
+            }
+        }
+    }
+}

package/dist/src/query/Builder.d.ts

@@ -0,0 +1,106 @@
+import { Connection } from "../connection/Connection.js";
+import type { WhereClause, OrderClause } from "../types/index.js";
+import type { Model } from "../model/Model.js";
+type RelationConstraint = (query: Builder<any>) => void | Builder<any>;
+export interface Paginator<T> {
+    data: T[];
+    current_page: number;
+    per_page: number;
+    total: number;
+    last_page: number;
+    from: number;
+    to: number;
+}
+export declare class Builder<T = Record<string, any>> {
+    connection: Connection;
+    tableName: string;
+    columns: string[];
+    wheres: WhereClause[];
+    orders: OrderClause[];
+    groups: string[];
+    havings: string[];
+    limitValue?: number;
+    offsetValue?: number;
+    joins: string[];
+    distinctFlag: boolean;
+    model?: typeof Model;
+    eagerLoads: string[];
+    constructor(connection: Connection, table: string);
+    setModel(model: typeof Model): this;
+    table(table: string): this;
+    select(...columns: string[]): this;
+    distinct(): this;
+    where(column: string | Record<string, any>, operator?: string | any, value?: any, boolean?: "and" | "or", scope?: string): this;
+    orWhere(column: string | Record<string, any>, operator?: string | any, value?: any): this;
+    whereIn(column: string, values: any[], boolean?: "and" | "or", scope?: string): this;
+    whereNotIn(column: string, values: any[], boolean?: "and" | "or", scope?: string): this;
+    whereNull(column: string, boolean?: "and" | "or", scope?: string): this;
+    whereNotNull(column: string, boolean?: "and" | "or", scope?: string): this;
+    whereBetween(column: string, values: [any, any], boolean?: "and" | "or", scope?: string): this;
+    whereNotBetween(column: string, values: [any, any], boolean?: "and" | "or", scope?: string): this;
+    whereRaw(sql: string, boolean?: "and" | "or", scope?: string): this;
+    whereColumn(first: string, operator: string, second: string, boolean?: "and" | "or"): this;
+    whereExists(sql: string, boolean?: "and" | "or", not?: boolean): this;
+    orderBy(column: string, direction?: "asc" | "desc"): this;
+    groupBy(...columns: string[]): this;
+    having(column: string, operator: string, value: any): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    forPage(page: number, perPage?: number): this;
+    join(table: string, first: string, operator: string, second: string, type?: string): this;
+    leftJoin(table: string, first: string, operator: string, second: string): this;
+    rightJoin(table: string, first: string, operator: string, second: string): this;
+    with(...relations: string[]): this;
+    withoutGlobalScope(scope: string): this;
+    withoutGlobalScopes(): this;
+    withTrashed(): this;
+    onlyTrashed(): this;
+    scope(name: string, ...args: any[]): this;
+    has(relationName: string, operator?: string | RelationConstraint, count?: number, callback?: RelationConstraint): this;
+    orHas(relationName: string, operator?: string | RelationConstraint, count?: number, callback?: RelationConstraint): this;
+    whereHas(relationName: string, callback?: RelationConstraint, operator?: string, count?: number): this;
+    orWhereHas(relationName: string, callback?: RelationConstraint, operator?: string, count?: number): this;
+    doesntHave(relationName: string, callback?: RelationConstraint): this;
+    whereDoesntHave(relationName: string, callback?: RelationConstraint): this;
+    withCount(relationName: string, alias?: string): this;
+    withSum(relationName: string, column: string, alias?: string): this;
+    withAvg(relationName: string, column: string, alias?: string): this;
+    withMin(relationName: string, column: string, alias?: string): this;
+    withMax(relationName: string, column: string, alias?: string): this;
+    addSelect(...columns: string[]): this;
+    clone(): Builder<T>;
+    wrapColumn(value: string): string;
+    escapeValue(value: any): string;
+    private wrap;
+    private wrapValue;
+    private escape;
+    private compileWheres;
+    private compileOrders;
+    private compileGroups;
+    private compileHavings;
+    private compileLimit;
+    private compileOffset;
+    private compileColumns;
+    private isRawColumn;
+    toSql(): string;
+    get(): Promise<T[]>;
+    first(): Promise<T | null>;
+    find(id: any, column?: string): Promise<T | null>;
+    pluck(column: string): Promise<any[]>;
+    private aggregate;
+    count(column?: string): Promise<number>;
+    sum(column: string): Promise<number>;
+    avg(column: string): Promise<number>;
+    min(column: string): Promise<any>;
+    max(column: string): Promise<any>;
+    paginate(perPage?: number, page?: number): Promise<Paginator<T>>;
+    insert(data: Partial<T> | Partial<T>[]): Promise<any>;
+    insertGetId(data: Partial<T>, idColumn?: string): Promise<any>;
+    update(data: Partial<T>): Promise<any>;
+    delete(): Promise<any>;
+    restore(): Promise<any>;
+    exists(): Promise<boolean>;
+    private getModelRelation;
+    private withAggregate;
+}
+export {};