@orchestr-sh/orchestr 1.10.0 → 1.11.0

package/dist/Database/DatabaseServiceProvider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseServiceProvider.mjs","names":[],"sources":["../../src/Database/DatabaseServiceProvider.ts"],"sourcesContent":["/**\n * DatabaseServiceProvider\n *\n * Registers database services into the container\n */\n\nimport { ServiceProvider } from '@/Foundation/ServiceProvider';\nimport { DrizzleAdapter } from './Adapters/DrizzleAdapter';\nimport { DatabaseManager } from './DatabaseManager';\n\nexport class DatabaseServiceProvider extends ServiceProvider {\n  /**\n   * Register database services\n   */\n  register(): void {\n    this.app.singleton('db', () => {\n      const config = (this.app.make('config') as any).items?.database || {\n        default: 'sqlite',\n        connections: {\n          sqlite: {\n            adapter: 'drizzle',\n            driver: 'better-sqlite3',\n            database: ':memory:',\n          },\n        },\n      };\n\n      const manager = new DatabaseManager(config);\n\n      // Register Drizzle adapter\n      manager.registerAdapter('drizzle', (config) => new DrizzleAdapter(config));\n\n      return manager;\n    });\n  }\n\n  /**\n   * Boot database services\n   */\n  async boot(): Promise<void> {\n    // Optionally auto-connect to the default connection\n    // const db = this.app.make<DatabaseManager>('db');\n    // await db.connection().connect();\n  }\n}\n"],"mappings":"2LAUA,IAAa,EAAb,cAA6C,CAAgB,CAI3D,UAAiB,CACf,KAAK,IAAI,UAAU,SAAY,CAY7B,IAAM,EAAU,IAAI,EAXJ,KAAK,IAAI,KAAK,SAAS,CAAS,OAAO,UAAY,CACjE,QAAS,SACT,YAAa,CACX,OAAQ,CACN,QAAS,UACT,OAAQ,iBACR,SAAU,WACX,CACF,CACF,CAE0C,CAK3C,OAFA,EAAQ,gBAAgB,UAAY,GAAW,IAAI,EAAe,EAAO,CAAC,CAEnE,GACP,CAMJ,MAAM,MAAsB"}

package/dist/Database/Ensemble/Concerns/HasAttributes.d.cts

@@ -0,0 +1,47 @@
+//#region src/Database/Ensemble/Concerns/HasAttributes.d.ts
+/**
+ * HasAttributes Concern
+ *
+ * Provides attribute handling functionality for models
+ */
+interface HasAttributes {
+  /**
+   * The model's attributes
+   */
+  attributes: Record<string, any>;
+  /**
+   * The model's original attributes
+   */
+  original: Record<string, any>;
+  /**
+   * The attributes that should be cast
+   */
+  casts: Record<string, string>;
+  /**
+   * The attributes that should be hidden
+   */
+  hidden: string[];
+  /**
+   * The attributes that should be visible
+   */
+  visible: string[];
+  /**
+   * The accessors to append
+   */
+  appends: string[];
+}
+/**
+ * Cast types supported by the model
+ */
+type CastType = 'int' | 'integer' | 'real' | 'float' | 'double' | 'decimal' | 'string' | 'bool' | 'boolean' | 'object' | 'array' | 'json' | 'collection' | 'date' | 'datetime' | 'timestamp';
+/**
+ * Attribute mutator function type
+ */
+type AttributeMutator = (value: any) => void;
+/**
+ * Attribute accessor function type
+ */
+type AttributeAccessor = () => any;
+//#endregion
+export { AttributeAccessor, AttributeMutator, CastType, HasAttributes };
+//# sourceMappingURL=HasAttributes.d.cts.map

package/dist/Database/Ensemble/Concerns/HasAttributes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasAttributes.d.cts","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasAttributes.ts"],"mappings":";;AAMA;;;;UAAiB,aAAA;EAcR;;;EAVP,UAAA,EAAY,MAAA;EAAA;;;EAKZ,QAAA,EAAU,MAAA;EAKH;;;EAAP,KAAA,EAAO,MAAA;EAeA;;AAMT;EAhBE,MAAA;;;;EAKA,OAAA;EAgC0B;;;EA3B1B,OAAA;AAAA;;;;KAMU,QAAA;;;;KAqBA,gBAAA,IAAoB,KAAA;;;;KAKpB,iBAAA"}

package/dist/Database/Ensemble/Concerns/HasAttributes.d.mts

@@ -0,0 +1,47 @@
+//#region src/Database/Ensemble/Concerns/HasAttributes.d.ts
+/**
+ * HasAttributes Concern
+ *
+ * Provides attribute handling functionality for models
+ */
+interface HasAttributes {
+  /**
+   * The model's attributes
+   */
+  attributes: Record<string, any>;
+  /**
+   * The model's original attributes
+   */
+  original: Record<string, any>;
+  /**
+   * The attributes that should be cast
+   */
+  casts: Record<string, string>;
+  /**
+   * The attributes that should be hidden
+   */
+  hidden: string[];
+  /**
+   * The attributes that should be visible
+   */
+  visible: string[];
+  /**
+   * The accessors to append
+   */
+  appends: string[];
+}
+/**
+ * Cast types supported by the model
+ */
+type CastType = 'int' | 'integer' | 'real' | 'float' | 'double' | 'decimal' | 'string' | 'bool' | 'boolean' | 'object' | 'array' | 'json' | 'collection' | 'date' | 'datetime' | 'timestamp';
+/**
+ * Attribute mutator function type
+ */
+type AttributeMutator = (value: any) => void;
+/**
+ * Attribute accessor function type
+ */
+type AttributeAccessor = () => any;
+//#endregion
+export { AttributeAccessor, AttributeMutator, CastType, HasAttributes };
+//# sourceMappingURL=HasAttributes.d.mts.map

package/dist/Database/Ensemble/Concerns/HasAttributes.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasAttributes.d.mts","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasAttributes.ts"],"mappings":";;AAMA;;;;UAAiB,aAAA;EAcR;;;EAVP,UAAA,EAAY,MAAA;EAAA;;;EAKZ,QAAA,EAAU,MAAA;EAKH;;;EAAP,KAAA,EAAO,MAAA;EAeA;;AAMT;EAhBE,MAAA;;;;EAKA,OAAA;EAgC0B;;;EA3B1B,OAAA;AAAA;;;;KAMU,QAAA;;;;KAqBA,gBAAA,IAAoB,KAAA;;;;KAKpB,iBAAA"}

package/dist/Database/Ensemble/Concerns/HasDynamicRelations.cjs

@@ -0,0 +1 @@
+require(`../../../_virtual/_rolldown/runtime.cjs`);function e(e,t,...n){if(t&&t.kind===`method`)return t.addInitializer(function(){let n=t.name,r=e;Object.defineProperty(this,n,{get(){let e=r.call(this),t=function(...t){return e};return t.then=function(t,n){return e.getResults().then(t,n)},t.catch=function(t){return e.getResults().catch(t)},t.finally=function(t){return e.getResults().finally(t)},t},configurable:!0,enumerable:!1})}),e;let r=n[0];if(r&&typeof r==`object`&&`value`in r){let e=r.value;return delete r.value,delete r.writable,r.get=function(){let t=e.call(this),n=function(...e){return t};return n.then=function(e,n){return t.getResults().then(e,n)},n.catch=function(e){return t.getResults().catch(e)},n.finally=function(e){return t.getResults().finally(e)},n},r}return e}function t(e,t,n){Object.defineProperty(e,t,{get(){let e=n.call(this),t=function(...t){return e};return t.then=function(t,n){return e.getResults().then(t,n)},t.catch=function(t){return e.getResults().catch(t)},t.finally=function(t){return e.getResults().finally(t)},t},enumerable:!1,configurable:!0})}exports.DynamicRelation=e,exports.defineDynamicRelation=t;

package/dist/Database/Ensemble/Concerns/HasDynamicRelations.d.cts

@@ -0,0 +1,74 @@
+import { HasOne } from "../Relations/HasOne.cjs";
+import { HasMany } from "../Relations/HasMany.cjs";
+import { BelongsTo } from "../Relations/BelongsTo.cjs";
+import { BelongsToMany } from "../Relations/BelongsToMany.cjs";
+import { MorphMany } from "../Relations/MorphMany.cjs";
+import { MorphTo } from "../Relations/MorphTo.cjs";
+import { MorphToMany } from "../Relations/MorphToMany.cjs";
+import { MorphedByMany } from "../Relations/MorphedByMany.cjs";
+import { MorphOne } from "../Relations/MorphOne.cjs";
+import { Ensemble } from "../Ensemble.cjs";
+
+//#region src/Database/Ensemble/Concerns/HasDynamicRelations.d.ts
+/**
+ * Type for a dynamic relation that can be both called and awaited
+ * @deprecated Use the relation return type directly and let the decorator handle the dual behavior
+ */
+type DynamicRelationAccessor<T> = (() => any) & PromiseLike<T>;
+/**
+ * Type helper for dynamic relations
+ * Use this to type relationship properties that work both as methods and promises
+ *
+ * @example
+ * class Post extends Ensemble {
+ *   declare user: BelongsToAccessor<User, this>;
+ *
+ *   @DynamicRelation
+ *   user(): BelongsTo<User, this> {
+ *     return this.belongsTo(User);
+ *   }
+ * }
+ *
+ * const user = await post.user; // Type: User
+ * const query = post.user(); // Type: BelongsTo<User, Post>
+ */
+type BelongsToAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated | Promise<TRelated | null> | (() => BelongsTo<TRelated, TParent>);
+type HasOneAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated | Promise<TRelated | null> | (() => HasOne<TRelated, TParent>);
+type HasManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => HasMany<TRelated, TParent>);
+type BelongsToManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => BelongsToMany<TRelated, TParent>);
+type MorphOneAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated | Promise<TRelated | null> | (() => MorphOne<TRelated, TParent>);
+type MorphManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => MorphMany<TRelated, TParent>);
+type MorphToAccessor<TRelated extends Ensemble> = TRelated | Promise<TRelated | null> | (() => MorphTo<any>);
+type MorphToManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => MorphToMany<TRelated, TParent>);
+type MorphedByManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => MorphedByMany<TRelated, TParent>);
+/**
+ * Decorator to convert a relationship method into a dynamic property
+ *
+ * @example
+ * class Post extends Ensemble {
+ *   @DynamicRelation
+ *   user!: DynamicRelationAccessor<User>;
+ *   user(): BelongsTo<User, this> {
+ *     return this.belongsTo(User, 'user_id');
+ *   }
+ *
+ *   @DynamicRelation
+ *   comments!: DynamicRelationAccessor<Comment[]>;
+ *   comments(): HasMany<Comment, this> {
+ *     return this.hasMany(Comment);
+ *   }
+ * }
+ *
+ * // Now you can use:
+ * const user = await post.user;  // Type: User
+ * const comments = await post.comments;  // Type: Comment[]
+ */
+declare function DynamicRelation(value: any, context?: any, ...rest: any[]): any;
+/**
+ * Helper to define dynamic relation getters programmatically
+ * Use this if you can't use decorators
+ */
+declare function defineDynamicRelation<T>(target: T, relationName: string, relationMethod: () => any): void;
+//#endregion
+export { BelongsToAccessor, BelongsToManyAccessor, DynamicRelation, DynamicRelationAccessor, HasManyAccessor, HasOneAccessor, MorphManyAccessor, MorphOneAccessor, MorphToAccessor, MorphToManyAccessor, MorphedByManyAccessor, defineDynamicRelation };
+//# sourceMappingURL=HasDynamicRelations.d.cts.map

package/dist/Database/Ensemble/Concerns/HasDynamicRelations.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasDynamicRelations.d.cts","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasDynamicRelations.ts"],"mappings":";;;;;;;;;;;;;;;;KA2NY,uBAAA,oBAA2C,WAAA,CAAY,CAAA;;;;;;;;;;;;;;;;;;KAmBvD,iBAAA,kBAAiB,QAAA,kBACqC,QAAA,IAG9D,QAAA,GACA,OAAA,CAAQ,QAAA,kBAC4E,SAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAErE,cAAA,kBAAc,QAAA,kBACwC,QAAA,IAG9D,QAAA,GACA,OAAA,CAAQ,QAAA,kBACsE,MAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAE/D,eAAA,kBAAe,QAAA,kBACuC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aACwE,OAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAEjE,qBAAA,kBAAqB,QAAA,kBACiC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aACoF,aAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAE7E,gBAAA,kBAAgB,QAAA,kBACsC,QAAA,IAG9D,QAAA,GACA,OAAA,CAAQ,QAAA,kBAC0E,QAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAEnE,iBAAA,kBAAiB,QAAA,kBACqC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aAC4E,SAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAErE,eAAA,kBAAe,QAAA,IACvB,QAAA,GACA,OAAA,CAAQ,QAAA,kBAAD,OAAA;AAAA,KAGC,mBAAA,kBAAmB,QAAA,kBACmC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aACgF,WAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAEzE,qBAAA,kBAAqB,QAAA,kBACiC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aACoF,aAAA,CAAjB,QAAA,EAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;iBAwBzE,eAAA,CAAgB,KAAA,OAAY,OAAA,WAAkB,IAAA;AA3E9D;;;;AAAA,iBA4JgB,qBAAA,GAAA,CAAyB,MAAA,EAAQ,CAAA,EAAG,YAAA,UAAsB,cAAA"}

package/dist/Database/Ensemble/Concerns/HasDynamicRelations.d.mts

@@ -0,0 +1,74 @@
+import { HasOne } from "../Relations/HasOne.mjs";
+import { HasMany } from "../Relations/HasMany.mjs";
+import { BelongsTo } from "../Relations/BelongsTo.mjs";
+import { BelongsToMany } from "../Relations/BelongsToMany.mjs";
+import { MorphMany } from "../Relations/MorphMany.mjs";
+import { MorphTo } from "../Relations/MorphTo.mjs";
+import { MorphToMany } from "../Relations/MorphToMany.mjs";
+import { MorphedByMany } from "../Relations/MorphedByMany.mjs";
+import { MorphOne } from "../Relations/MorphOne.mjs";
+import { Ensemble } from "../Ensemble.mjs";
+
+//#region src/Database/Ensemble/Concerns/HasDynamicRelations.d.ts
+/**
+ * Type for a dynamic relation that can be both called and awaited
+ * @deprecated Use the relation return type directly and let the decorator handle the dual behavior
+ */
+type DynamicRelationAccessor<T> = (() => any) & PromiseLike<T>;
+/**
+ * Type helper for dynamic relations
+ * Use this to type relationship properties that work both as methods and promises
+ *
+ * @example
+ * class Post extends Ensemble {
+ *   declare user: BelongsToAccessor<User, this>;
+ *
+ *   @DynamicRelation
+ *   user(): BelongsTo<User, this> {
+ *     return this.belongsTo(User);
+ *   }
+ * }
+ *
+ * const user = await post.user; // Type: User
+ * const query = post.user(); // Type: BelongsTo<User, Post>
+ */
+type BelongsToAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated | Promise<TRelated | null> | (() => BelongsTo<TRelated, TParent>);
+type HasOneAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated | Promise<TRelated | null> | (() => HasOne<TRelated, TParent>);
+type HasManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => HasMany<TRelated, TParent>);
+type BelongsToManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => BelongsToMany<TRelated, TParent>);
+type MorphOneAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated | Promise<TRelated | null> | (() => MorphOne<TRelated, TParent>);
+type MorphManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => MorphMany<TRelated, TParent>);
+type MorphToAccessor<TRelated extends Ensemble> = TRelated | Promise<TRelated | null> | (() => MorphTo<any>);
+type MorphToManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => MorphToMany<TRelated, TParent>);
+type MorphedByManyAccessor<TRelated extends Ensemble, TParent extends Ensemble> = TRelated[] | Promise<TRelated[]> | (() => MorphedByMany<TRelated, TParent>);
+/**
+ * Decorator to convert a relationship method into a dynamic property
+ *
+ * @example
+ * class Post extends Ensemble {
+ *   @DynamicRelation
+ *   user!: DynamicRelationAccessor<User>;
+ *   user(): BelongsTo<User, this> {
+ *     return this.belongsTo(User, 'user_id');
+ *   }
+ *
+ *   @DynamicRelation
+ *   comments!: DynamicRelationAccessor<Comment[]>;
+ *   comments(): HasMany<Comment, this> {
+ *     return this.hasMany(Comment);
+ *   }
+ * }
+ *
+ * // Now you can use:
+ * const user = await post.user;  // Type: User
+ * const comments = await post.comments;  // Type: Comment[]
+ */
+declare function DynamicRelation(value: any, context?: any, ...rest: any[]): any;
+/**
+ * Helper to define dynamic relation getters programmatically
+ * Use this if you can't use decorators
+ */
+declare function defineDynamicRelation<T>(target: T, relationName: string, relationMethod: () => any): void;
+//#endregion
+export { BelongsToAccessor, BelongsToManyAccessor, DynamicRelation, DynamicRelationAccessor, HasManyAccessor, HasOneAccessor, MorphManyAccessor, MorphOneAccessor, MorphToAccessor, MorphToManyAccessor, MorphedByManyAccessor, defineDynamicRelation };
+//# sourceMappingURL=HasDynamicRelations.d.mts.map

package/dist/Database/Ensemble/Concerns/HasDynamicRelations.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasDynamicRelations.d.mts","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasDynamicRelations.ts"],"mappings":";;;;;;;;;;;;;;;;KA2NY,uBAAA,oBAA2C,WAAA,CAAY,CAAA;;;;;;;;;;;;;;;;;;KAmBvD,iBAAA,kBAAiB,QAAA,kBACqC,QAAA,IAG9D,QAAA,GACA,OAAA,CAAQ,QAAA,kBAC4E,SAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAErE,cAAA,kBAAc,QAAA,kBACwC,QAAA,IAG9D,QAAA,GACA,OAAA,CAAQ,QAAA,kBACsE,MAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAE/D,eAAA,kBAAe,QAAA,kBACuC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aACwE,OAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAEjE,qBAAA,kBAAqB,QAAA,kBACiC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aACoF,aAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAE7E,gBAAA,kBAAgB,QAAA,kBACsC,QAAA,IAG9D,QAAA,GACA,OAAA,CAAQ,QAAA,kBAC0E,QAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAEnE,iBAAA,kBAAiB,QAAA,kBACqC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aAC4E,SAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAErE,eAAA,kBAAe,QAAA,IACvB,QAAA,GACA,OAAA,CAAQ,QAAA,kBAAD,OAAA;AAAA,KAGC,mBAAA,kBAAmB,QAAA,kBACmC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aACgF,WAAA,CAAjB,QAAA,EAAU,OAAA;AAAA,KAEzE,qBAAA,kBAAqB,QAAA,kBACiC,QAAA,IAG9D,QAAA,KACA,OAAA,CAAQ,QAAA,aACoF,aAAA,CAAjB,QAAA,EAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;iBAwBzE,eAAA,CAAgB,KAAA,OAAY,OAAA,WAAkB,IAAA;AA3E9D;;;;AAAA,iBA4JgB,qBAAA,GAAA,CAAyB,MAAA,EAAQ,CAAA,EAAG,YAAA,UAAsB,cAAA"}

package/dist/Database/Ensemble/Concerns/HasDynamicRelations.mjs

@@ -0,0 +1,2 @@
+function e(e,t,...n){if(t&&t.kind===`method`)return t.addInitializer(function(){let n=t.name,r=e;Object.defineProperty(this,n,{get(){let e=r.call(this),t=function(...t){return e};return t.then=function(t,n){return e.getResults().then(t,n)},t.catch=function(t){return e.getResults().catch(t)},t.finally=function(t){return e.getResults().finally(t)},t},configurable:!0,enumerable:!1})}),e;let r=n[0];if(r&&typeof r==`object`&&`value`in r){let e=r.value;return delete r.value,delete r.writable,r.get=function(){let t=e.call(this),n=function(...e){return t};return n.then=function(e,n){return t.getResults().then(e,n)},n.catch=function(e){return t.getResults().catch(e)},n.finally=function(e){return t.getResults().finally(e)},n},r}return e}function t(e,t,n){Object.defineProperty(e,t,{get(){let e=n.call(this),t=function(...t){return e};return t.then=function(t,n){return e.getResults().then(t,n)},t.catch=function(t){return e.getResults().catch(t)},t.finally=function(t){return e.getResults().finally(t)},t},enumerable:!1,configurable:!0})}export{e as DynamicRelation,t as defineDynamicRelation};
+//# sourceMappingURL=HasDynamicRelations.mjs.map

package/dist/Database/Ensemble/Concerns/HasDynamicRelations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasDynamicRelations.mjs","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasDynamicRelations.ts"],"sourcesContent":["/**\n * HasDynamicRelations Concern\n *\n * Provides dynamic relationship access similar to PHP's __get magic method\n * Allows accessing relationships as properties: user.posts instead of user.posts().get()\n */\n\nimport { Relation } from '@/Database/Ensemble/Relations';\n\n/**\n * Check if a value is a Relation instance\n */\nfunction isRelation(value: any): boolean {\n  return value && value instanceof Relation;\n}\n\n/**\n * Create a hybrid function/promise for relationship access\n * This allows both: await user.posts AND user.posts().get()\n */\nfunction createRelationshipProxy(relationGetter: () => any): any {\n  // Create a function that returns the relation when called\n  const fn: any = function (...args: any[]) {\n    return relationGetter();\n  };\n\n  // Make the function thenable (Promise-like) by adding then/catch methods\n  fn.then = function (onFulfilled?: any, onRejected?: any) {\n    return relationGetter().getResults().then(onFulfilled, onRejected);\n  };\n\n  fn.catch = function (onRejected?: any) {\n    return relationGetter().getResults().catch(onRejected);\n  };\n\n  fn.finally = function (onFinally?: any) {\n    return relationGetter().getResults().finally(onFinally);\n  };\n\n  return fn;\n}\n\n/**\n * List of method prefixes that should never be treated as relationships\n */\nconst EXCLUDED_PREFIXES = [\n  'get',\n  'set',\n  'is',\n  'has',\n  'should',\n  'can',\n  'fill',\n  'save',\n  'delete',\n  'update',\n  'create',\n  'find',\n  'where',\n  'with',\n  'load',\n  'fresh',\n  'toObject',\n  'toJSON',\n  'toString',\n  'valueOf',\n];\n\n/**\n * List of known internal methods that should never be treated as relationships\n */\nconst EXCLUDED_METHODS = [\n  'constructor',\n  'getTable',\n  'getKeyName',\n  'getKey',\n  'getAttribute',\n  'setAttribute',\n  'newQuery',\n  'newInstance',\n  'getConnection',\n  'query',\n  'getDirty',\n  'relationLoaded',\n  'getRelation',\n  'setRelation',\n  'syncOriginal',\n  'refresh',\n  'touch',\n  'makeHidden',\n  'makeVisible',\n];\n\n/**\n * Check if a method name should be excluded from dynamic relation detection\n */\nfunction shouldExcludeMethod(methodName: string): boolean {\n  // Exclude if in the excluded methods list\n  if (EXCLUDED_METHODS.includes(methodName)) {\n    return true;\n  }\n\n  // Exclude if it starts with an underscore (private/internal)\n  if (methodName.startsWith('_')) {\n    return true;\n  }\n\n  // Exclude if it starts with any excluded prefix\n  for (const prefix of EXCLUDED_PREFIXES) {\n    if (methodName.startsWith(prefix)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Wrap an Ensemble instance with a Proxy that automatically resolves relationships\n */\n/**\n * List of internal properties that should never be proxied\n */\nconst INTERNAL_PROPERTIES = new Set([\n  'attributes',\n  'original',\n  'relations',\n  'exists',\n  'wasRecentlyCreated',\n  'table',\n  'primaryKey',\n  'incrementing',\n  'keyType',\n  'fillable',\n  'guarded',\n  'hidden',\n  'visible',\n  'appends',\n  'casts',\n  'timestamps',\n  'connection',\n  'dynamicRelations',\n]);\n\nexport function withDynamicRelations<T extends object>(instance: T): T {\n  return new Proxy(instance, {\n    get(target: any, property: string | symbol, receiver: any): any {\n      // Always pass through symbol properties and internal properties\n      // Use target directly, not receiver, to avoid proxy recursion\n      if (typeof property === 'symbol' || INTERNAL_PROPERTIES.has(property as string)) {\n        return target[property];\n      }\n\n      // Get the original value from target, not receiver\n      const value = target[property];\n\n      // Check if dynamic relations are enabled for this instance\n      const dynamicEnabled = target.dynamicRelations === true;\n\n      // If dynamic relations are disabled or it's not a string property, return as-is\n      if (!dynamicEnabled || typeof property !== 'string') {\n        return value;\n      }\n\n      // If it's not a function, return as-is\n      if (typeof value !== 'function') {\n        return value;\n      }\n\n      // Exclude methods that should never be treated as relationships\n      if (shouldExcludeMethod(property)) {\n        return value;\n      }\n\n      // Check if this property is a loaded relation\n      if (target.relationLoaded && target.relationLoaded(property)) {\n        return target.getRelation(property);\n      }\n\n      // For relationship methods (zero-parameter functions), return a hybrid proxy\n      // The proxy will lazily call the method when needed (when awaited or called)\n      const boundMethod = value.bind(target);\n      const paramCount = value.length;\n\n      // Only create proxy for zero-parameter methods (potential relationships)\n      if (paramCount === 0) {\n        // Return a hybrid that can be both called and awaited\n        // We don't call the method here - we let the proxy call it when needed\n        return createRelationshipProxy(boundMethod);\n      }\n\n      // Return the original value for methods with parameters\n      return value;\n    },\n\n    // Pass through set operations without interference\n    set(target: any, property: string | symbol, value: any, receiver: any): boolean {\n      return Reflect.set(target, property, value, receiver);\n    },\n  });\n}\n\n/**\n * Mix dynamic relations functionality into a class\n */\nexport abstract class HasDynamicRelationsMixin {\n  /**\n   * Enable dynamic relationship access\n   * Call this in your model constructor after super()\n   */\n  protected enableDynamicRelations(): this {\n    return withDynamicRelations(this);\n  }\n}\n\n/**\n * Type for a dynamic relation that can be both called and awaited\n * @deprecated Use the relation return type directly and let the decorator handle the dual behavior\n */\nexport type DynamicRelationAccessor<T> = (() => any) & PromiseLike<T>;\n\n/**\n * Type helper for dynamic relations\n * Use this to type relationship properties that work both as methods and promises\n *\n * @example\n * class Post extends Ensemble {\n *   declare user: BelongsToAccessor<User, this>;\n *\n *   @DynamicRelation\n *   user(): BelongsTo<User, this> {\n *     return this.belongsTo(User);\n *   }\n * }\n *\n * const user = await post.user; // Type: User\n * const query = post.user(); // Type: BelongsTo<User, Post>\n */\nexport type BelongsToAccessor<\n  TRelated extends import('@/Database/Ensemble/Ensemble').Ensemble,\n  TParent extends import('@/Database/Ensemble/Ensemble').Ensemble,\n> =\n  | TRelated\n  | Promise<TRelated | null>\n  | (() => import('@/Database/Ensemble/Relations/BelongsTo').BelongsTo<TRelated, TParent>);\n\nexport type HasOneAccessor<\n  TRelated extends import('@/Database/Ensemble/Ensemble').Ensemble,\n  TParent extends import('@/Database/Ensemble/Ensemble').Ensemble,\n> =\n  | TRelated\n  | Promise<TRelated | null>\n  | (() => import('@/Database/Ensemble/Relations/HasOne').HasOne<TRelated, TParent>);\n\nexport type HasManyAccessor<\n  TRelated extends import('@/Database/Ensemble/Ensemble').Ensemble,\n  TParent extends import('@/Database/Ensemble/Ensemble').Ensemble,\n> =\n  | TRelated[]\n  | Promise<TRelated[]>\n  | (() => import('@/Database/Ensemble/Relations/HasMany').HasMany<TRelated, TParent>);\n\nexport type BelongsToManyAccessor<\n  TRelated extends import('@/Database/Ensemble/Ensemble').Ensemble,\n  TParent extends import('@/Database/Ensemble/Ensemble').Ensemble,\n> =\n  | TRelated[]\n  | Promise<TRelated[]>\n  | (() => import('@/Database/Ensemble/Relations/BelongsToMany').BelongsToMany<TRelated, TParent>);\n\nexport type MorphOneAccessor<\n  TRelated extends import('@/Database/Ensemble/Ensemble').Ensemble,\n  TParent extends import('@/Database/Ensemble/Ensemble').Ensemble,\n> =\n  | TRelated\n  | Promise<TRelated | null>\n  | (() => import('@/Database/Ensemble/Relations/MorphOne').MorphOne<TRelated, TParent>);\n\nexport type MorphManyAccessor<\n  TRelated extends import('@/Database/Ensemble/Ensemble').Ensemble,\n  TParent extends import('@/Database/Ensemble/Ensemble').Ensemble,\n> =\n  | TRelated[]\n  | Promise<TRelated[]>\n  | (() => import('@/Database/Ensemble/Relations/MorphMany').MorphMany<TRelated, TParent>);\n\nexport type MorphToAccessor<TRelated extends import('@/Database/Ensemble/Ensemble').Ensemble> =\n  | TRelated\n  | Promise<TRelated | null>\n  | (() => import('@/Database/Ensemble/Relations/MorphTo').MorphTo<any>);\n\nexport type MorphToManyAccessor<\n  TRelated extends import('@/Database/Ensemble/Ensemble').Ensemble,\n  TParent extends import('@/Database/Ensemble/Ensemble').Ensemble,\n> =\n  | TRelated[]\n  | Promise<TRelated[]>\n  | (() => import('@/Database/Ensemble/Relations/MorphToMany').MorphToMany<TRelated, TParent>);\n\nexport type MorphedByManyAccessor<\n  TRelated extends import('@/Database/Ensemble/Ensemble').Ensemble,\n  TParent extends import('@/Database/Ensemble/Ensemble').Ensemble,\n> =\n  | TRelated[]\n  | Promise<TRelated[]>\n  | (() => import('@/Database/Ensemble/Relations/MorphedByMany').MorphedByMany<TRelated, TParent>);\n\n/**\n * Decorator to convert a relationship method into a dynamic property\n *\n * @example\n * class Post extends Ensemble {\n *   @DynamicRelation\n *   user!: DynamicRelationAccessor<User>;\n *   user(): BelongsTo<User, this> {\n *     return this.belongsTo(User, 'user_id');\n *   }\n *\n *   @DynamicRelation\n *   comments!: DynamicRelationAccessor<Comment[]>;\n *   comments(): HasMany<Comment, this> {\n *     return this.hasMany(Comment);\n *   }\n * }\n *\n * // Now you can use:\n * const user = await post.user;  // Type: User\n * const comments = await post.comments;  // Type: Comment[]\n */\nexport function DynamicRelation(value: any, context?: any, ...rest: any[]) {\n  // Modern decorator (TypeScript 5+ with context as second parameter)\n  if (context && context.kind === 'method') {\n    context.addInitializer(function (this: any) {\n      const methodName = context.name;\n      const originalMethod = value;\n\n      // Define a getter on the instance\n      Object.defineProperty(this, methodName, {\n        get() {\n          const relation = originalMethod.call(this);\n\n          const fn: any = function (...args: any[]) {\n            return relation;\n          };\n\n          fn.then = function (resolve?: any, reject?: any) {\n            return relation.getResults().then(resolve, reject);\n          };\n\n          fn.catch = function (reject?: any) {\n            return relation.getResults().catch(reject);\n          };\n\n          fn.finally = function (onFinally?: any) {\n            return relation.getResults().finally(onFinally);\n          };\n\n          return fn;\n        },\n        configurable: true,\n        enumerable: false,\n      });\n    });\n\n    return value;\n  }\n\n  // Legacy decorator (target, propertyKey, descriptor)\n  const target = value;\n  const propertyKey = context;\n  const descriptor = rest[0] as PropertyDescriptor;\n\n  if (descriptor && typeof descriptor === 'object' && 'value' in descriptor) {\n    const originalMethod = descriptor.value;\n\n    delete descriptor.value;\n    delete descriptor.writable;\n\n    descriptor.get = function (this: any) {\n      const relation = originalMethod.call(this);\n\n      const fn: any = function (...args: any[]) {\n        return relation;\n      };\n\n      fn.then = function (resolve?: any, reject?: any) {\n        return relation.getResults().then(resolve, reject);\n      };\n\n      fn.catch = function (reject?: any) {\n        return relation.getResults().catch(reject);\n      };\n\n      fn.finally = function (onFinally?: any) {\n        return relation.getResults().finally(onFinally);\n      };\n\n      return fn;\n    };\n\n    return descriptor;\n  }\n\n  return value;\n}\n\n/**\n * Helper to define dynamic relation getters programmatically\n * Use this if you can't use decorators\n */\nexport function defineDynamicRelation<T>(target: T, relationName: string, relationMethod: () => any): void {\n  Object.defineProperty(target, relationName, {\n    get(this: any) {\n      const relation = relationMethod.call(this);\n\n      const fn: any = function (...args: any[]) {\n        return relation;\n      };\n\n      fn.then = function (resolve?: any, reject?: any) {\n        return relation.getResults().then(resolve, reject);\n      };\n\n      fn.catch = function (reject?: any) {\n        return relation.getResults().catch(reject);\n      };\n\n      fn.finally = function (onFinally?: any) {\n        return relation.getResults().finally(onFinally);\n      };\n\n      return fn;\n    },\n    enumerable: false,\n    configurable: true,\n  });\n}\n"],"mappings":"AAyUA,SAAgB,EAAgB,EAAY,EAAe,GAAG,EAAa,CAEzE,GAAI,GAAW,EAAQ,OAAS,SAiC9B,OAhCA,EAAQ,eAAe,UAAqB,CAC1C,IAAM,EAAa,EAAQ,KACrB,EAAiB,EAGvB,OAAO,eAAe,KAAM,EAAY,CACtC,KAAM,CACJ,IAAM,EAAW,EAAe,KAAK,KAAK,CAEpC,EAAU,SAAU,GAAG,EAAa,CACxC,OAAO,GAeT,MAZA,GAAG,KAAO,SAAU,EAAe,EAAc,CAC/C,OAAO,EAAS,YAAY,CAAC,KAAK,EAAS,EAAO,EAGpD,EAAG,MAAQ,SAAU,EAAc,CACjC,OAAO,EAAS,YAAY,CAAC,MAAM,EAAO,EAG5C,EAAG,QAAU,SAAU,EAAiB,CACtC,OAAO,EAAS,YAAY,CAAC,QAAQ,EAAU,EAG1C,GAET,aAAc,GACd,WAAY,GACb,CAAC,EACF,CAEK,EAMT,IAAM,EAAa,EAAK,GAExB,GAAI,GAAc,OAAO,GAAe,UAAY,UAAW,EAAY,CACzE,IAAM,EAAiB,EAAW,MA2BlC,OAzBA,OAAO,EAAW,MAClB,OAAO,EAAW,SAElB,EAAW,IAAM,UAAqB,CACpC,IAAM,EAAW,EAAe,KAAK,KAAK,CAEpC,EAAU,SAAU,GAAG,EAAa,CACxC,OAAO,GAeT,MAZA,GAAG,KAAO,SAAU,EAAe,EAAc,CAC/C,OAAO,EAAS,YAAY,CAAC,KAAK,EAAS,EAAO,EAGpD,EAAG,MAAQ,SAAU,EAAc,CACjC,OAAO,EAAS,YAAY,CAAC,MAAM,EAAO,EAG5C,EAAG,QAAU,SAAU,EAAiB,CACtC,OAAO,EAAS,YAAY,CAAC,QAAQ,EAAU,EAG1C,GAGF,EAGT,OAAO,EAOT,SAAgB,EAAyB,EAAW,EAAsB,EAAiC,CACzG,OAAO,eAAe,EAAQ,EAAc,CAC1C,KAAe,CACb,IAAM,EAAW,EAAe,KAAK,KAAK,CAEpC,EAAU,SAAU,GAAG,EAAa,CACxC,OAAO,GAeT,MAZA,GAAG,KAAO,SAAU,EAAe,EAAc,CAC/C,OAAO,EAAS,YAAY,CAAC,KAAK,EAAS,EAAO,EAGpD,EAAG,MAAQ,SAAU,EAAc,CACjC,OAAO,EAAS,YAAY,CAAC,MAAM,EAAO,EAG5C,EAAG,QAAU,SAAU,EAAiB,CACtC,OAAO,EAAS,YAAY,CAAC,QAAQ,EAAU,EAG1C,GAET,WAAY,GACZ,aAAc,GACf,CAAC"}

package/dist/Database/Ensemble/Concerns/HasRelationships.cjs

@@ -0,0 +1 @@
+const e=require(`../../../_virtual/_rolldown/runtime.cjs`),t=require(`../Relations/Relation.cjs`),n=require(`../Relations/BelongsTo.cjs`),r=require(`../Relations/BelongsToMany.cjs`),i=require(`../Relations/HasMany.cjs`),a=require(`../Relations/HasOne.cjs`),o=require(`../Relations/MorphOne.cjs`),s=require(`../Relations/MorphMany.cjs`),c=require(`../Relations/MorphTo.cjs`),l=require(`../Relations/MorphToMany.cjs`),u=require(`../Relations/MorphedByMany.cjs`);r.init_BelongsToMany(),t.init_Relation();var d=class{relations={};hasOne(e,t,n){let r=new e,i=t||this.getForeignKey(),o=n||this.getKeyName();return new a.HasOne(r.newQuery(),this,i,o)}hasMany(e,t,n){let r=new e,a=t||this.getForeignKey(),o=n||this.getKeyName();return new i.HasMany(r.newQuery(),this,a,o)}belongsTo(e,t,r,i){let a=new e,o=i||this.snake(a.constructor.name);t||=o+`_`+a.getKeyName();let s=r||a.getKeyName();return new n.BelongsTo(a.newQuery(),this,t,s,o)}belongsToMany(e,t,n,i,a,o,s){let c=new e;t||=this.joiningTable(c),n||=this.getForeignKey(),i||=c.getForeignKey();let l=a||this.getKeyName(),u=o||c.getKeyName();return new r.BelongsToMany(c.newQuery(),this,t,n,i,l,u,s||``)}morphOne(t,n,r,i,a){let s=new t,{MorphOne:c}=(o.init_MorphOne(),e.__toCommonJS(o.MorphOne_exports)),l=a||this.getKeyName();return new c(s.newQuery(),this,n,r,i,l)}morphMany(t,n,r,i,a){let o=new t,{MorphMany:c}=(s.init_MorphMany(),e.__toCommonJS(s.MorphMany_exports)),l=a||this.getKeyName();return new c(o.newQuery(),this,n,r,i,l)}morphTo(t,n,r,i){let{MorphTo:a}=(c.init_MorphTo(),e.__toCommonJS(c.MorphTo_exports)),o=n||`${t}_type`,s=r||`${t}_id`,l=i||`id`;return new a(this.newQuery(),this,s,o,l,t)}morphToMany(t,n,r,i,a,o,s,c=!1){let u=new t,{MorphToMany:d}=(l.init_MorphToMany(),e.__toCommonJS(l.MorphToMany_exports)),f=r||`${n}s`,p=i||`${n}_id`,m=a||u.getForeignKey(),h=`${n}_type`,g=o||this.getKeyName(),_=s||u.getKeyName();return new d(u.newQuery(),this,n,f,p,m,h,g,_,``,c)}morphedByMany(t,n,r,i,a,o,s){let c=new t,{MorphedByMany:l}=(u.init_MorphedByMany(),e.__toCommonJS(u.MorphedByMany_exports)),d=r||`${n}s`,f=i||`${n}_id`,p=a||c.getForeignKey(),m=`${n}_type`,h=o||this.getKeyName(),g=s||c.getKeyName();return new l(c.newQuery(),this,n,d,f,p,m,h,g,``)}joiningTable(e){let t=[this.snake(this.constructor.name),this.snake(e.constructor.name)];return t.sort(),t.join(`_`)}getForeignKey(){return this.snake(this.constructor.name)+`_`+this.getKeyName()}getRelationshipFromMethod(e){let n=this[e]();if(!(n instanceof t.Relation))throw Error(`Relationship method must return an object of type Relation (${e})`);return n}getRelation(e){return this.relations[e]}setRelation(e,t){return this.relations[e]=t,this}unsetRelation(e){return delete this.relations[e],this}getRelations(){return this.relations}setRelations(e){return this.relations=e,this}relationLoaded(e){return e in this.relations}async load(e){let t=Array.isArray(e)?e:[e];for(let e of t)if(!this.relationLoaded(e)){let t=await this.getRelationshipFromMethod(e).getResults();this.setRelation(e,t)}return this}async loadMissing(e){let t=(Array.isArray(e)?e:[e]).filter(e=>!this.relationLoaded(e));return t.length>0&&await this.load(t),this}async touch(){return!0}snake(e){return e.replace(/([A-Z])/g,`_$1`).toLowerCase().replace(/^_/,``)}};exports.HasRelationshipsMixin=d;

package/dist/Database/Ensemble/Concerns/HasRelationships.d.cts

@@ -0,0 +1,129 @@
+import { HasOne } from "../Relations/HasOne.cjs";
+import { HasMany } from "../Relations/HasMany.cjs";
+import { BelongsTo } from "../Relations/BelongsTo.cjs";
+import { BelongsToMany } from "../Relations/BelongsToMany.cjs";
+import { MorphMany } from "../Relations/MorphMany.cjs";
+import { MorphTo } from "../Relations/MorphTo.cjs";
+import { MorphToMany } from "../Relations/MorphToMany.cjs";
+import { MorphedByMany } from "../Relations/MorphedByMany.cjs";
+import { EnsembleBuilder } from "../EnsembleBuilder.cjs";
+import { MorphOne } from "../Relations/MorphOne.cjs";
+import { Ensemble } from "../Ensemble.cjs";
+
+//#region src/Database/Ensemble/Concerns/HasRelationships.d.ts
+interface RelationshipConfig {
+  type: 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany' | 'hasOneThrough' | 'hasManyThrough' | 'morphTo' | 'morphMany' | 'morphOne' | 'morphToMany' | 'morphedByMany';
+  related: string;
+  foreignKey?: string;
+  localKey?: string;
+  relation?: string;
+}
+declare abstract class HasRelationshipsMixin {
+  /**
+   * The loaded relationships for the model
+   */
+  protected relations: Record<string, any>;
+  /**
+   * Define a one-to-one relationship
+   */
+  protected hasOne<TRelated extends Ensemble>(related: new () => TRelated, foreignKey?: string, localKey?: string): HasOne<TRelated, any>;
+  /**
+   * Define a one-to-many relationship
+   */
+  protected hasMany<TRelated extends Ensemble>(related: new () => TRelated, foreignKey?: string, localKey?: string): HasMany<TRelated, any>;
+  /**
+   * Define an inverse one-to-one or many relationship
+   */
+  protected belongsTo<TRelated extends Ensemble>(related: new () => TRelated, foreignKey?: string, ownerKey?: string, relation?: string): BelongsTo<TRelated, any>;
+  /**
+   * Define a many-to-many relationship
+   */
+  protected belongsToMany<TRelated extends Ensemble>(related: new () => TRelated, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string, relation?: string): BelongsToMany<TRelated, any>;
+  /**
+   * Define a polymorphic one-to-one relationship
+   */
+  protected morphOne<TRelated extends Ensemble>(related: new () => TRelated, name: string, type?: string | null, id?: string | null, localKey?: string): MorphOne<TRelated, any>;
+  /**
+   * Define a polymorphic one-to-many relationship
+   */
+  protected morphMany<TRelated extends Ensemble>(related: new () => TRelated, name: string, type?: string | null, id?: string | null, localKey?: string): MorphMany<TRelated, any>;
+  /**
+   * Define a polymorphic inverse relationship
+   */
+  protected morphTo(name: string, type?: string, id?: string, ownerKey?: string): MorphTo<any>;
+  /**
+   * Define a polymorphic many-to-many relationship
+   */
+  protected morphToMany<TRelated extends Ensemble>(related: new () => TRelated, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string, inverse?: boolean): MorphToMany<TRelated, any>;
+  /**
+   * Define the inverse of a polymorphic many-to-many relationship
+   */
+  protected morphedByMany<TRelated extends Ensemble>(related: new () => TRelated, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): MorphedByMany<TRelated, any>;
+  /**
+   * Get the joining table name for a many-to-many relation
+   */
+  protected joiningTable(related: Ensemble): string;
+  /**
+   * Get the default foreign key name for the model
+   */
+  protected getForeignKey(): string;
+  /**
+   * Get a relationship value from a method
+   */
+  protected getRelationshipFromMethod(method: string): any;
+  /**
+   * Get a relationship instance by name
+   */
+  getRelation(relation: string): any;
+  /**
+   * Set the given relationship on the model
+   */
+  setRelation(relation: string, value: any): this;
+  /**
+   * Unset a loaded relationship
+   */
+  unsetRelation(relation: string): this;
+  /**
+   * Get all the loaded relations for the instance
+   */
+  getRelations(): Record<string, any>;
+  /**
+   * Set the entire relations array on the model
+   */
+  setRelations(relations: Record<string, any>): this;
+  /**
+   * Determine if the given relation is loaded
+   */
+  relationLoaded(key: string): boolean;
+  /**
+   * Load a relationship if it hasn't been loaded yet
+   */
+  load(relations: string | string[]): Promise<this>;
+  /**
+   * Eager load relations on the model
+   */
+  loadMissing(relations: string | string[]): Promise<this>;
+  /**
+   * Touch the owning relations of the model
+   */
+  touch(): Promise<boolean>;
+  /**
+   * Create a new model query instance for the model
+   */
+  protected abstract newQuery(): EnsembleBuilder<any>;
+  /**
+   * Get the table name (from Ensemble)
+   */
+  protected abstract getTable(): string;
+  /**
+   * Get the primary key name (from Ensemble)
+   */
+  protected abstract getKeyName(): string;
+  /**
+   * Convert a string to snake case
+   */
+  protected snake(value: string): string;
+}
+//#endregion
+export { HasRelationshipsMixin, RelationshipConfig };
+//# sourceMappingURL=HasRelationships.d.cts.map

package/dist/Database/Ensemble/Concerns/HasRelationships.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasRelationships.d.cts","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasRelationships.ts"],"mappings":";;;;;;;;;;;;;UAciB,kBAAA;EACf,IAAA;EAYA,OAAA;EACA,UAAA;EACA,QAAA;EACA,QAAA;AAAA;AAAA,uBAGoB,qBAAA;EALpB;;;EAAA,UASU,SAAA,EAAW,MAAA;EAPb;AAGV;;EAHU,UAYE,MAAA,kBAAwB,QAAA,CAAA,CAChC,OAAA,YAAmB,QAAA,EACnB,UAAA,WACA,QAAA,YACC,MAAA,CAAO,QAAA;EATW;;;EAAA,UA0BX,OAAA,kBAAyB,QAAA,CAAA,CACjC,OAAA,YAAmB,QAAA,EACnB,UAAA,WACA,QAAA,YACC,OAAA,CAAQ,QAAA;EArBR;;;EAAA,UAsCO,SAAA,kBAA2B,QAAA,CAAA,CACnC,OAAA,YAAmB,QAAA,EACnB,UAAA,WACA,QAAA,WACA,QAAA,YACC,SAAA,CAAU,QAAA;EAtBV;;;EAAA,UA+CO,aAAA,kBAA+B,QAAA,CAAA,CACvC,OAAA,YAAmB,QAAA,EACnB,KAAA,WACA,eAAA,WACA,eAAA,WACA,SAAA,WACA,UAAA,WACA,QAAA,YACC,aAAA,CAAc,QAAA;EAjCd;;;EAAA,UAoEO,QAAA,kBAA0B,QAAA,CAAA,CAClC,OAAA,YAAmB,QAAA,EACnB,IAAA,UACA,IAAA,kBACA,EAAA,kBACA,QAAA,YACmE,QAAA,CAAR,QAAA;EAzC1D;;;EAAA,UAsDO,SAAA,kBAA2B,QAAA,CAAA,CACnC,OAAA,YAAmB,QAAA,EACnB,IAAA,UACA,IAAA,kBACA,EAAA,kBACA,QAAA,YACqE,SAAA,CAAR,QAAA;EAnBM;;;EAAA,UAgC3D,OAAA,CACR,IAAA,UACA,IAAA,WACA,EAAA,WACA,QAAA,YAjB4D,OAAA;EAAS;;;EAAA,UAiC7D,WAAA,kBAA6B,QAAA,CAAA,CACrC,OAAA,YAAmB,QAAA,EACnB,IAAA,UACA,KAAA,WACA,eAAA,WACA,eAAA,WACA,SAAA,WACA,UAAA,WACA,OAAA,aACyE,WAAA,CAAR,QAAA;EAAA;;;EAAA,UA8BzD,aAAA,kBAA+B,QAAA,CAAA,CACvC,OAAA,YAAmB,QAAA,EACnB,IAAA,UACA,KAAA,WACA,eAAA,WACA,eAAA,WACA,SAAA,WACA,UAAA,YAC6E,aAAA,CAAR,QAAA;EAAA;;;EAAA,UA6B7D,YAAA,CAAa,OAAA,EAAS,QAAA;EA8DD;;;EAAA,UAlDrB,aAAA,CAAA;EAuGqB;;;EAAA,UAhGrB,yBAAA,CAA0B,MAAA;EAjRf;;;EA8Rd,WAAA,CAAY,QAAA;EAxRE;;;EA+Rd,WAAA,CAAY,QAAA,UAAkB,KAAA;EA5RlC;;;EAoSI,aAAA,CAAc,QAAA;EAnRc;;;EA2R5B,YAAA,CAAA,GAAgB,MAAA;EAxRrB;;;EA+RK,YAAA,CAAa,SAAA,EAAW,MAAA;EA7QX;;;EAqRb,cAAA,CAAe,GAAA;EAnRpB;;;EA0RW,IAAA,CAAK,SAAA,sBAA+B,OAAA;EAvRpC;;;EAuSA,WAAA,CAAY,SAAA,sBAA+B,OAAA;EA7QnC;;;EA2RR,KAAA,CAAA,GAAS,OAAA;EAxRpB;;;EAAA,mBAgSiB,QAAA,CAAA,GAAY,eAAA;EA5R5B;;;EAAA,mBAiSgB,QAAA,CAAA;EA9PiB;;;EAAA,mBAmQjB,UAAA,CAAA;EAhQjB;;;EAAA,UAqQQ,KAAA,CAAM,KAAA;AAAA"}

package/dist/Database/Ensemble/Concerns/HasRelationships.d.mts

@@ -0,0 +1,129 @@
+import { HasOne } from "../Relations/HasOne.mjs";
+import { HasMany } from "../Relations/HasMany.mjs";
+import { BelongsTo } from "../Relations/BelongsTo.mjs";
+import { BelongsToMany } from "../Relations/BelongsToMany.mjs";
+import { MorphMany } from "../Relations/MorphMany.mjs";
+import { MorphTo } from "../Relations/MorphTo.mjs";
+import { MorphToMany } from "../Relations/MorphToMany.mjs";
+import { MorphedByMany } from "../Relations/MorphedByMany.mjs";
+import { EnsembleBuilder } from "../EnsembleBuilder.mjs";
+import { MorphOne } from "../Relations/MorphOne.mjs";
+import { Ensemble } from "../Ensemble.mjs";
+
+//#region src/Database/Ensemble/Concerns/HasRelationships.d.ts
+interface RelationshipConfig {
+  type: 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany' | 'hasOneThrough' | 'hasManyThrough' | 'morphTo' | 'morphMany' | 'morphOne' | 'morphToMany' | 'morphedByMany';
+  related: string;
+  foreignKey?: string;
+  localKey?: string;
+  relation?: string;
+}
+declare abstract class HasRelationshipsMixin {
+  /**
+   * The loaded relationships for the model
+   */
+  protected relations: Record<string, any>;
+  /**
+   * Define a one-to-one relationship
+   */
+  protected hasOne<TRelated extends Ensemble>(related: new () => TRelated, foreignKey?: string, localKey?: string): HasOne<TRelated, any>;
+  /**
+   * Define a one-to-many relationship
+   */
+  protected hasMany<TRelated extends Ensemble>(related: new () => TRelated, foreignKey?: string, localKey?: string): HasMany<TRelated, any>;
+  /**
+   * Define an inverse one-to-one or many relationship
+   */
+  protected belongsTo<TRelated extends Ensemble>(related: new () => TRelated, foreignKey?: string, ownerKey?: string, relation?: string): BelongsTo<TRelated, any>;
+  /**
+   * Define a many-to-many relationship
+   */
+  protected belongsToMany<TRelated extends Ensemble>(related: new () => TRelated, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string, relation?: string): BelongsToMany<TRelated, any>;
+  /**
+   * Define a polymorphic one-to-one relationship
+   */
+  protected morphOne<TRelated extends Ensemble>(related: new () => TRelated, name: string, type?: string | null, id?: string | null, localKey?: string): MorphOne<TRelated, any>;
+  /**
+   * Define a polymorphic one-to-many relationship
+   */
+  protected morphMany<TRelated extends Ensemble>(related: new () => TRelated, name: string, type?: string | null, id?: string | null, localKey?: string): MorphMany<TRelated, any>;
+  /**
+   * Define a polymorphic inverse relationship
+   */
+  protected morphTo(name: string, type?: string, id?: string, ownerKey?: string): MorphTo<any>;
+  /**
+   * Define a polymorphic many-to-many relationship
+   */
+  protected morphToMany<TRelated extends Ensemble>(related: new () => TRelated, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string, inverse?: boolean): MorphToMany<TRelated, any>;
+  /**
+   * Define the inverse of a polymorphic many-to-many relationship
+   */
+  protected morphedByMany<TRelated extends Ensemble>(related: new () => TRelated, name: string, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): MorphedByMany<TRelated, any>;
+  /**
+   * Get the joining table name for a many-to-many relation
+   */
+  protected joiningTable(related: Ensemble): string;
+  /**
+   * Get the default foreign key name for the model
+   */
+  protected getForeignKey(): string;
+  /**
+   * Get a relationship value from a method
+   */
+  protected getRelationshipFromMethod(method: string): any;
+  /**
+   * Get a relationship instance by name
+   */
+  getRelation(relation: string): any;
+  /**
+   * Set the given relationship on the model
+   */
+  setRelation(relation: string, value: any): this;
+  /**
+   * Unset a loaded relationship
+   */
+  unsetRelation(relation: string): this;
+  /**
+   * Get all the loaded relations for the instance
+   */
+  getRelations(): Record<string, any>;
+  /**
+   * Set the entire relations array on the model
+   */
+  setRelations(relations: Record<string, any>): this;
+  /**
+   * Determine if the given relation is loaded
+   */
+  relationLoaded(key: string): boolean;
+  /**
+   * Load a relationship if it hasn't been loaded yet
+   */
+  load(relations: string | string[]): Promise<this>;
+  /**
+   * Eager load relations on the model
+   */
+  loadMissing(relations: string | string[]): Promise<this>;
+  /**
+   * Touch the owning relations of the model
+   */
+  touch(): Promise<boolean>;
+  /**
+   * Create a new model query instance for the model
+   */
+  protected abstract newQuery(): EnsembleBuilder<any>;
+  /**
+   * Get the table name (from Ensemble)
+   */
+  protected abstract getTable(): string;
+  /**
+   * Get the primary key name (from Ensemble)
+   */
+  protected abstract getKeyName(): string;
+  /**
+   * Convert a string to snake case
+   */
+  protected snake(value: string): string;
+}
+//#endregion
+export { HasRelationshipsMixin, RelationshipConfig };
+//# sourceMappingURL=HasRelationships.d.mts.map

package/dist/Database/Ensemble/Concerns/HasRelationships.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasRelationships.d.mts","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasRelationships.ts"],"mappings":";;;;;;;;;;;;;UAciB,kBAAA;EACf,IAAA;EAYA,OAAA;EACA,UAAA;EACA,QAAA;EACA,QAAA;AAAA;AAAA,uBAGoB,qBAAA;EALpB;;;EAAA,UASU,SAAA,EAAW,MAAA;EAPb;AAGV;;EAHU,UAYE,MAAA,kBAAwB,QAAA,CAAA,CAChC,OAAA,YAAmB,QAAA,EACnB,UAAA,WACA,QAAA,YACC,MAAA,CAAO,QAAA;EATW;;;EAAA,UA0BX,OAAA,kBAAyB,QAAA,CAAA,CACjC,OAAA,YAAmB,QAAA,EACnB,UAAA,WACA,QAAA,YACC,OAAA,CAAQ,QAAA;EArBR;;;EAAA,UAsCO,SAAA,kBAA2B,QAAA,CAAA,CACnC,OAAA,YAAmB,QAAA,EACnB,UAAA,WACA,QAAA,WACA,QAAA,YACC,SAAA,CAAU,QAAA;EAtBV;;;EAAA,UA+CO,aAAA,kBAA+B,QAAA,CAAA,CACvC,OAAA,YAAmB,QAAA,EACnB,KAAA,WACA,eAAA,WACA,eAAA,WACA,SAAA,WACA,UAAA,WACA,QAAA,YACC,aAAA,CAAc,QAAA;EAjCd;;;EAAA,UAoEO,QAAA,kBAA0B,QAAA,CAAA,CAClC,OAAA,YAAmB,QAAA,EACnB,IAAA,UACA,IAAA,kBACA,EAAA,kBACA,QAAA,YACmE,QAAA,CAAR,QAAA;EAzC1D;;;EAAA,UAsDO,SAAA,kBAA2B,QAAA,CAAA,CACnC,OAAA,YAAmB,QAAA,EACnB,IAAA,UACA,IAAA,kBACA,EAAA,kBACA,QAAA,YACqE,SAAA,CAAR,QAAA;EAnBM;;;EAAA,UAgC3D,OAAA,CACR,IAAA,UACA,IAAA,WACA,EAAA,WACA,QAAA,YAjB4D,OAAA;EAAS;;;EAAA,UAiC7D,WAAA,kBAA6B,QAAA,CAAA,CACrC,OAAA,YAAmB,QAAA,EACnB,IAAA,UACA,KAAA,WACA,eAAA,WACA,eAAA,WACA,SAAA,WACA,UAAA,WACA,OAAA,aACyE,WAAA,CAAR,QAAA;EAAA;;;EAAA,UA8BzD,aAAA,kBAA+B,QAAA,CAAA,CACvC,OAAA,YAAmB,QAAA,EACnB,IAAA,UACA,KAAA,WACA,eAAA,WACA,eAAA,WACA,SAAA,WACA,UAAA,YAC6E,aAAA,CAAR,QAAA;EAAA;;;EAAA,UA6B7D,YAAA,CAAa,OAAA,EAAS,QAAA;EA8DD;;;EAAA,UAlDrB,aAAA,CAAA;EAuGqB;;;EAAA,UAhGrB,yBAAA,CAA0B,MAAA;EAjRf;;;EA8Rd,WAAA,CAAY,QAAA;EAxRE;;;EA+Rd,WAAA,CAAY,QAAA,UAAkB,KAAA;EA5RlC;;;EAoSI,aAAA,CAAc,QAAA;EAnRc;;;EA2R5B,YAAA,CAAA,GAAgB,MAAA;EAxRrB;;;EA+RK,YAAA,CAAa,SAAA,EAAW,MAAA;EA7QX;;;EAqRb,cAAA,CAAe,GAAA;EAnRpB;;;EA0RW,IAAA,CAAK,SAAA,sBAA+B,OAAA;EAvRpC;;;EAuSA,WAAA,CAAY,SAAA,sBAA+B,OAAA;EA7QnC;;;EA2RR,KAAA,CAAA,GAAS,OAAA;EAxRpB;;;EAAA,mBAgSiB,QAAA,CAAA,GAAY,eAAA;EA5R5B;;;EAAA,mBAiSgB,QAAA,CAAA;EA9PiB;;;EAAA,mBAmQjB,UAAA,CAAA;EAhQjB;;;EAAA,UAqQQ,KAAA,CAAM,KAAA;AAAA"}

package/dist/Database/Ensemble/Concerns/HasRelationships.mjs

@@ -0,0 +1,2 @@
+import{__toCommonJS as e}from"../../../_virtual/_rolldown/runtime.mjs";import{Relation as t,init_Relation as n}from"../Relations/Relation.mjs";import{BelongsTo as r}from"../Relations/BelongsTo.mjs";import{BelongsToMany as i,init_BelongsToMany as a}from"../Relations/BelongsToMany.mjs";import{HasMany as o}from"../Relations/HasMany.mjs";import{HasOne as s}from"../Relations/HasOne.mjs";import{MorphOne_exports as c,init_MorphOne as l}from"../Relations/MorphOne.mjs";import{MorphMany_exports as u,init_MorphMany as d}from"../Relations/MorphMany.mjs";import{MorphTo_exports as f,init_MorphTo as p}from"../Relations/MorphTo.mjs";import{MorphToMany_exports as m,init_MorphToMany as h}from"../Relations/MorphToMany.mjs";import{MorphedByMany_exports as g,init_MorphedByMany as _}from"../Relations/MorphedByMany.mjs";a(),n();var v=class{relations={};hasOne(e,t,n){let r=new e,i=t||this.getForeignKey(),a=n||this.getKeyName();return new s(r.newQuery(),this,i,a)}hasMany(e,t,n){let r=new e,i=t||this.getForeignKey(),a=n||this.getKeyName();return new o(r.newQuery(),this,i,a)}belongsTo(e,t,n,i){let a=new e,o=i||this.snake(a.constructor.name);t||=o+`_`+a.getKeyName();let s=n||a.getKeyName();return new r(a.newQuery(),this,t,s,o)}belongsToMany(e,t,n,r,a,o,s){let c=new e;t||=this.joiningTable(c),n||=this.getForeignKey(),r||=c.getForeignKey();let l=a||this.getKeyName(),u=o||c.getKeyName();return new i(c.newQuery(),this,t,n,r,l,u,s||``)}morphOne(t,n,r,i,a){let o=new t,{MorphOne:s}=(l(),e(c)),u=a||this.getKeyName();return new s(o.newQuery(),this,n,r,i,u)}morphMany(t,n,r,i,a){let o=new t,{MorphMany:s}=(d(),e(u)),c=a||this.getKeyName();return new s(o.newQuery(),this,n,r,i,c)}morphTo(t,n,r,i){let{MorphTo:a}=(p(),e(f)),o=n||`${t}_type`,s=r||`${t}_id`,c=i||`id`;return new a(this.newQuery(),this,s,o,c,t)}morphToMany(t,n,r,i,a,o,s,c=!1){let l=new t,{MorphToMany:u}=(h(),e(m)),d=r||`${n}s`,f=i||`${n}_id`,p=a||l.getForeignKey(),g=`${n}_type`,_=o||this.getKeyName(),v=s||l.getKeyName();return new u(l.newQuery(),this,n,d,f,p,g,_,v,``,c)}morphedByMany(t,n,r,i,a,o,s){let c=new t,{MorphedByMany:l}=(_(),e(g)),u=r||`${n}s`,d=i||`${n}_id`,f=a||c.getForeignKey(),p=`${n}_type`,m=o||this.getKeyName(),h=s||c.getKeyName();return new l(c.newQuery(),this,n,u,d,f,p,m,h,``)}joiningTable(e){let t=[this.snake(this.constructor.name),this.snake(e.constructor.name)];return t.sort(),t.join(`_`)}getForeignKey(){return this.snake(this.constructor.name)+`_`+this.getKeyName()}getRelationshipFromMethod(e){let n=this[e]();if(!(n instanceof t))throw Error(`Relationship method must return an object of type Relation (${e})`);return n}getRelation(e){return this.relations[e]}setRelation(e,t){return this.relations[e]=t,this}unsetRelation(e){return delete this.relations[e],this}getRelations(){return this.relations}setRelations(e){return this.relations=e,this}relationLoaded(e){return e in this.relations}async load(e){let t=Array.isArray(e)?e:[e];for(let e of t)if(!this.relationLoaded(e)){let t=await this.getRelationshipFromMethod(e).getResults();this.setRelation(e,t)}return this}async loadMissing(e){let t=(Array.isArray(e)?e:[e]).filter(e=>!this.relationLoaded(e));return t.length>0&&await this.load(t),this}async touch(){return!0}snake(e){return e.replace(/([A-Z])/g,`_$1`).toLowerCase().replace(/^_/,``)}};export{v as HasRelationshipsMixin};
+//# sourceMappingURL=HasRelationships.mjs.map