speexjs 0.3.0 → 0.5.0

package/dist/server/auth/index.d.ts

@@ -1,10 +1,11 @@
 import { A as AuthUser, S as SessionGuard } from '../../session-guard-CZeN87L9.js';
 export { a as SessionGuardConfig, U as UserProvider } from '../../session-guard-CZeN87L9.js';
-import { M as Middleware } from '../../index-CMkhSDh7.js';
+import { M as Middleware } from '../../index-C4xilc_E.js';
 import '../../response-Ca8KWK5_.js';
 import 'node:http';
 import 'node:stream';
 import '../container/index.js';
+import '../../types-aW38f63o.js';
 
 interface TokenProvider {
     create(userId: string | number, tokenHash: string, name?: string, abilities?: string[]): Promise<void>;

package/dist/server/cache/index.d.ts

@@ -1,8 +1,9 @@
-import { M as Middleware } from '../../index-CMkhSDh7.js';
+import { M as Middleware } from '../../index-C4xilc_E.js';
 import '../container/index.js';
 import '../../response-Ca8KWK5_.js';
 import 'node:http';
 import 'node:stream';
+import '../../types-aW38f63o.js';
 
 interface CacheConfig {
     store?: "memory" | "file";

package/dist/server/controller/index.d.ts

@@ -1,6 +1,7 @@
-import { R as RouteContext } from '../../index-CMkhSDh7.js';
+import { R as RouteContext } from '../../index-C4xilc_E.js';
 import { Container } from '../container/index.js';
 import { S as SuperRequest, a as SuperResponse, b as Schema } from '../../response-Ca8KWK5_.js';
+import '../../types-aW38f63o.js';
 import 'node:http';
 import 'node:stream';
 

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

@@ -459,12 +459,25 @@ declare class Seeder {
 }
 
 declare class Model {
+    /** Primary key */
     id?: number | string;
+    /** Dynamic properties from database */
+    [key: string]: unknown;
     static table: string;
     static connection: QueryRunner | null;
     protected static queryRunner: QueryRunner | null;
+    private static relationDefs;
+    private static eagerLoads;
+    /** @internal cache for loaded relations on instances */
+    _relations: Record<string, unknown>;
     static setConnection(conn: QueryRunner): void;
     static query<T extends typeof Model>(this: T): QueryBuilder;
+    static hasOne(relatedModel: typeof Model, foreignKey?: string, localKey?: string): void;
+    static hasMany(relatedModel: typeof Model, foreignKey?: string, localKey?: string): void;
+    static belongsTo(relatedModel: typeof Model, foreignKey?: string, ownerKey?: string): void;
+    static belongsToMany(relatedModel: typeof Model, pivotTable?: string, foreignPivotKey?: string, relatedPivotKey?: string): void;
+    static morphMany(relatedModel: typeof Model, morphName: string): void;
+    static with(...relations: string[]): void;
     static all<T extends typeof Model>(this: T): Promise<InstanceType<T>[]>;
     static find<T extends typeof Model>(this: T, id: number | string): Promise<InstanceType<T> | null>;
     static where<T extends typeof Model>(this: T, column: string, value: any): Promise<QueryBuilder>;
@@ -472,8 +485,7 @@ declare class Model {
     static updateOrCreate<T extends typeof Model>(this: T, attributes: Record<string, any>, values?: Record<string, any>): Promise<InstanceType<T>>;
     save(): Promise<void>;
     delete(): Promise<void>;
-    static belongsTo<T extends typeof Model>(this: T, relatedModel: typeof Model, foreignKey?: string, ownerKey?: string): any;
-    static hasMany<T extends typeof Model>(this: T, relatedModel: typeof Model, foreignKey?: string, localKey?: string): any;
+    private static loadRelations;
     private static hydrate;
     private getData;
 }

package/dist/server/database/index.js

@@ -2813,10 +2813,15 @@ var Seeder = class {
 
 // src/server/database/model.ts
 var Model = class {
+  /** Primary key */
   id;
   static table = "";
   static connection = null;
   static queryRunner = null;
+  static relationDefs = /* @__PURE__ */ new Map();
+  static eagerLoads = /* @__PURE__ */ new Map();
+  /** @internal cache for loaded relations on instances */
+  _relations = {};
   static setConnection(conn) {
     this.connection = conn;
     this.queryRunner = conn;
@@ -2827,14 +2832,74 @@ var Model = class {
     }
     return new QueryBuilder(this.queryRunner, this.table);
   }
+  // ─── Relations Definition ──────────────────────────────────
+  static hasOne(relatedModel, foreignKey, localKey) {
+    const key = `hasOne:${relatedModel.table}`;
+    this.relationDefs.set(key, {
+      type: "hasOne",
+      relatedModel,
+      foreignKey: foreignKey ?? `${this.table}_id`,
+      localKey: localKey ?? "id"
+    });
+  }
+  static hasMany(relatedModel, foreignKey, localKey) {
+    const key = `hasMany:${relatedModel.table}`;
+    this.relationDefs.set(key, {
+      type: "hasMany",
+      relatedModel,
+      foreignKey: foreignKey ?? `${this.table}_id`,
+      localKey: localKey ?? "id"
+    });
+  }
+  static belongsTo(relatedModel, foreignKey, ownerKey) {
+    const key = `belongsTo:${relatedModel.table}`;
+    this.relationDefs.set(key, {
+      type: "belongsTo",
+      relatedModel,
+      foreignKey: foreignKey ?? `${relatedModel.table}_id`,
+      localKey: ownerKey ?? "id"
+    });
+  }
+  static belongsToMany(relatedModel, pivotTable, foreignPivotKey, relatedPivotKey) {
+    const tables = [this.table, relatedModel.table].sort();
+    const key = `belongsToMany:${relatedModel.table}`;
+    this.relationDefs.set(key, {
+      type: "belongsToMany",
+      relatedModel,
+      foreignKey: foreignPivotKey ?? `${this.table}_id`,
+      localKey: relatedPivotKey ?? `${relatedModel.table}_id`,
+      pivotTable: pivotTable ?? `${tables[0]}_${tables[1]}`
+    });
+  }
+  static morphMany(relatedModel, morphName) {
+    const key = `morphMany:${morphName}`;
+    this.relationDefs.set(key, {
+      type: "morphMany",
+      relatedModel,
+      foreignKey: `${morphName}_id`,
+      localKey: "id",
+      morphName
+    });
+  }
+  // ─── Eager Loading ─────────────────────────────────────────
+  static with(...relations) {
+    for (const rel of relations) {
+      this.eagerLoads.set(rel, true);
+    }
+  }
+  // ─── Query Shortcuts ───────────────────────────────────────
   static async all() {
     const rows = await this.query().get();
-    return rows.map((row) => this.hydrate(row));
+    const instances = rows.map((row) => this.hydrate(row));
+    await this.loadRelations(instances);
+    return instances;
   }
   static async find(id) {
     const row = await this.query().find(id);
     if (!row) return null;
-    return this.hydrate(row);
+    const instance = this.hydrate(row);
+    await this.loadRelations([instance]);
+    return instance;
   }
   static async where(column, value) {
     return this.query().where(column, value);
@@ -2861,6 +2926,7 @@ var Model = class {
     }
     return this.create({ ...attributes, ...values });
   }
+  // ─── Instance Methods ──────────────────────────────────────
   async save() {
     const ModelClass = this.constructor;
     const id = this.id;
@@ -2878,22 +2944,64 @@ var Model = class {
       await ModelClass.query().where("id", id).delete();
     }
   }
-  static belongsTo(relatedModel, foreignKey, ownerKey) {
-    const related = relatedModel.table;
-    const fk = foreignKey ?? `${related}_id`;
-    const ok = ownerKey ?? "id";
-    return this.query().where(fk, ok);
-  }
-  static hasMany(relatedModel, foreignKey, localKey) {
-    const related = relatedModel.table;
-    const fk = foreignKey ?? `${this.table}_id`;
-    const lk = localKey ?? "id";
-    return this.query().join(related, fk, "=", lk);
+  // ─── Relation Loader ───────────────────────────────────────
+  static async loadRelations(instances) {
+    if (instances.length === 0) return;
+    for (const [key, def] of this.relationDefs) {
+      const shouldLoad = this.eagerLoads.size === 0 || this.eagerLoads.has(key.split(":")[1] ?? key);
+      if (!shouldLoad) continue;
+      const localIds = instances.map((i) => i[def.localKey]).filter(Boolean);
+      if (def.type === "belongsTo") {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const related = await def.relatedModel.query().whereIn(def.localKey, localIds).get();
+        for (const inst of instances) {
+          inst._relations[key] = related.find((r) => r[def.localKey] === inst[def.foreignKey]) ?? null;
+        }
+      }
+      if (def.type === "hasMany") {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const related = await def.relatedModel.query().whereIn(def.foreignKey, localIds).get();
+        for (const inst of instances) {
+          inst._relations[key] = related.filter((r) => r[def.foreignKey] === inst[def.localKey]);
+        }
+      }
+      if (def.type === "hasOne") {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const related = await def.relatedModel.query().whereIn(def.foreignKey, localIds).get();
+        for (const inst of instances) {
+          inst._relations[key] = related.find((r) => r[def.foreignKey] === inst[def.localKey]) ?? null;
+        }
+      }
+      if (def.type === "belongsToMany" && def.pivotTable) {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const pivotQb = new QueryBuilder(this.queryRunner, def.pivotTable);
+        const pivotRows = await pivotQb.whereIn(def.foreignKey, localIds).get();
+        const relatedIds = pivotRows.map((r) => r[def.localKey]);
+        if (relatedIds.length > 0) {
+          const related = await def.relatedModel.query().whereIn("id", relatedIds).get();
+          for (const inst of instances) {
+            const pivots = pivotRows.filter((p) => p[def.foreignKey] === inst[def.localKey]);
+            inst._relations[key] = pivots.map((p) => related.find((r) => r.id === p[def.localKey])).filter(Boolean);
+          }
+        } else {
+          for (const inst of instances) {
+            inst._relations[key] = [];
+          }
+        }
+      }
+      if (def.type === "morphMany" && def.morphName) {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const related = await def.relatedModel.query().where(`${def.morphName}_type`, this.name).whereIn(`${def.morphName}_id`, localIds).get();
+        for (const inst of instances) {
+          inst._relations[key] = related.filter((r) => r[`${def.morphName}_id`] === inst[def.localKey]);
+        }
+      }
+    }
   }
+  // ─── Internal Helpers ──────────────────────────────────────
   static hydrate(data) {
     const instance = new this();
     for (const [key, value] of Object.entries(data)) {
-      ;
       instance[key] = value;
     }
     return instance;
@@ -2913,7 +3021,7 @@ var Model = class {
       "getData"
     ]);
     for (const key of ownKeys) {
-      if (typeof key === "string" && !classKeys.has(key) && key !== "constructor") {
+      if (typeof key === "string" && !classKeys.has(key) && key !== "constructor" && !key.startsWith("_")) {
         data[key] = instance[key];
       }
     }