@orchestr-sh/orchestr 1.10.0 → 1.11.1

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"HasRelationships.mjs","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasRelationships.ts"],"sourcesContent":["/**\n * HasRelationships Concern\n *\n * Provides relationship functionality to Ensemble models\n */\n\nimport { Ensemble } from '@/Database/Ensemble/Ensemble';\nimport { EnsembleBuilder } from '@/Database/Ensemble/EnsembleBuilder';\nimport { BelongsTo } from '@/Database/Ensemble/Relations/BelongsTo';\nimport { BelongsToMany } from '@/Database/Ensemble/Relations/BelongsToMany';\nimport { HasMany } from '@/Database/Ensemble/Relations/HasMany';\nimport { HasOne } from '@/Database/Ensemble/Relations/HasOne';\nimport { Relation } from '@/Database/Ensemble/Relations/Relation';\n\nexport interface RelationshipConfig {\n  type:\n    | 'hasOne'\n    | 'hasMany'\n    | 'belongsTo'\n    | 'belongsToMany'\n    | 'hasOneThrough'\n    | 'hasManyThrough'\n    | 'morphTo'\n    | 'morphMany'\n    | 'morphOne'\n    | 'morphToMany'\n    | 'morphedByMany';\n  related: string;\n  foreignKey?: string;\n  localKey?: string;\n  relation?: string;\n}\n\nexport abstract class HasRelationshipsMixin {\n  /**\n   * The loaded relationships for the model\n   */\n  protected relations: Record<string, any> = {};\n\n  /**\n   * Define a one-to-one relationship\n   */\n  protected hasOne<TRelated extends Ensemble>(\n    related: new () => TRelated,\n    foreignKey?: string,\n    localKey?: string\n  ): HasOne<TRelated, any> {\n    const instance = new related();\n\n    const finalForeignKey = foreignKey || this.getForeignKey();\n    const finalLocalKey = localKey || (this as any).getKeyName();\n\n    return new HasOne<TRelated, any>(\n      instance.newQuery() as EnsembleBuilder<TRelated>,\n      this as any,\n      finalForeignKey,\n      finalLocalKey\n    );\n  }\n\n  /**\n   * Define a one-to-many relationship\n   */\n  protected hasMany<TRelated extends Ensemble>(\n    related: new () => TRelated,\n    foreignKey?: string,\n    localKey?: string\n  ): HasMany<TRelated, any> {\n    const instance = new related();\n\n    const finalForeignKey = foreignKey || this.getForeignKey();\n    const finalLocalKey = localKey || (this as any).getKeyName();\n\n    return new HasMany<TRelated, any>(\n      instance.newQuery() as EnsembleBuilder<TRelated>,\n      this as any,\n      finalForeignKey,\n      finalLocalKey\n    );\n  }\n\n  /**\n   * Define an inverse one-to-one or many relationship\n   */\n  protected belongsTo<TRelated extends Ensemble>(\n    related: new () => TRelated,\n    foreignKey?: string,\n    ownerKey?: string,\n    relation?: string\n  ): BelongsTo<TRelated, any> {\n    const instance = new related();\n    const relationName = relation || this.snake(instance.constructor.name);\n\n    if (!foreignKey) {\n      // Generate foreign key from relation name + primary key\n      // Note: relationName should be singular (e.g., \"user\" not \"users\")\n      // If your model class is plural, pass the relation parameter explicitly\n      foreignKey = relationName + '_' + instance.getKeyName();\n    }\n\n    const finalOwnerKey = ownerKey || instance.getKeyName();\n\n    return new BelongsTo<TRelated, any>(\n      instance.newQuery() as EnsembleBuilder<TRelated>,\n      this as any,\n      foreignKey,\n      finalOwnerKey,\n      relationName\n    );\n  }\n\n  /**\n   * Define a many-to-many relationship\n   */\n  protected belongsToMany<TRelated extends Ensemble>(\n    related: new () => TRelated,\n    table?: string,\n    foreignPivotKey?: string,\n    relatedPivotKey?: string,\n    parentKey?: string,\n    relatedKey?: string,\n    relation?: string\n  ): BelongsToMany<TRelated, any> {\n    const instance = new related();\n\n    // If no table name was provided, use the default\n    if (!table) {\n      table = this.joiningTable(instance);\n    }\n\n    // Get the foreign key for the parent model\n    foreignPivotKey = foreignPivotKey || this.getForeignKey();\n\n    // Get the foreign key for the related model\n    relatedPivotKey = relatedPivotKey || instance.getForeignKey();\n\n    // Get the parent key\n    const finalParentKey = parentKey || (this as any).getKeyName();\n\n    // Get the related key\n    const finalRelatedKey = relatedKey || instance.getKeyName();\n\n    return new BelongsToMany<TRelated, any>(\n      instance.newQuery() as EnsembleBuilder<TRelated>,\n      this as any,\n      table,\n      foreignPivotKey,\n      relatedPivotKey,\n      finalParentKey,\n      finalRelatedKey,\n      relation || ''\n    );\n  }\n\n  /**\n   * Define a polymorphic one-to-one relationship\n   */\n  protected morphOne<TRelated extends Ensemble>(\n    related: new () => TRelated,\n    name: string,\n    type?: string | null,\n    id?: string | null,\n    localKey?: string\n  ): import('@/Database/Ensemble/Relations/MorphOne').MorphOne<TRelated, any> {\n    const instance = new related();\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const { MorphOne } = require('@/Database/Ensemble/Relations/MorphOne');\n\n    const finalLocalKey = localKey || (this as any).getKeyName();\n\n    return new MorphOne(instance.newQuery() as EnsembleBuilder<TRelated>, this as any, name, type, id, finalLocalKey);\n  }\n\n  /**\n   * Define a polymorphic one-to-many relationship\n   */\n  protected morphMany<TRelated extends Ensemble>(\n    related: new () => TRelated,\n    name: string,\n    type?: string | null,\n    id?: string | null,\n    localKey?: string\n  ): import('@/Database/Ensemble/Relations/MorphMany').MorphMany<TRelated, any> {\n    const instance = new related();\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const { MorphMany } = require('@/Database/Ensemble/Relations/MorphMany');\n\n    const finalLocalKey = localKey || (this as any).getKeyName();\n\n    return new MorphMany(instance.newQuery() as EnsembleBuilder<TRelated>, this as any, name, type, id, finalLocalKey);\n  }\n\n  /**\n   * Define a polymorphic inverse relationship\n   */\n  protected morphTo(\n    name: string,\n    type?: string,\n    id?: string,\n    ownerKey?: string\n  ): import('@/Database/Ensemble/Relations/MorphTo').MorphTo<any> {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const { MorphTo } = require('@/Database/Ensemble/Relations/MorphTo');\n\n    const finalType = type || `${name}_type`;\n    const finalId = id || `${name}_id`;\n    const finalOwnerKey = ownerKey || 'id';\n\n    // MorphTo needs special handling - creates query builder dynamically\n    return new MorphTo((this as any).newQuery() as any, this as any, finalId, finalType, finalOwnerKey, name);\n  }\n\n  /**\n   * Define a polymorphic many-to-many relationship\n   */\n  protected morphToMany<TRelated extends Ensemble>(\n    related: new () => TRelated,\n    name: string,\n    table?: string,\n    foreignPivotKey?: string,\n    relatedPivotKey?: string,\n    parentKey?: string,\n    relatedKey?: string,\n    inverse: boolean = false\n  ): import('@/Database/Ensemble/Relations/MorphToMany').MorphToMany<TRelated, any> {\n    const instance = new related();\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const { MorphToMany } = require('@/Database/Ensemble/Relations/MorphToMany');\n\n    const finalTable = table || `${name}s`;\n    const finalForeignPivotKey = foreignPivotKey || `${name}_id`;\n    const finalRelatedPivotKey = relatedPivotKey || instance.getForeignKey();\n    const morphType = `${name}_type`;\n    const finalParentKey = parentKey || (this as any).getKeyName();\n    const finalRelatedKey = relatedKey || instance.getKeyName();\n\n    return new MorphToMany(\n      instance.newQuery() as EnsembleBuilder<TRelated>,\n      this as any,\n      name,\n      finalTable,\n      finalForeignPivotKey,\n      finalRelatedPivotKey,\n      morphType,\n      finalParentKey,\n      finalRelatedKey,\n      '',\n      inverse\n    );\n  }\n\n  /**\n   * Define the inverse of a polymorphic many-to-many relationship\n   */\n  protected morphedByMany<TRelated extends Ensemble>(\n    related: new () => TRelated,\n    name: string,\n    table?: string,\n    foreignPivotKey?: string,\n    relatedPivotKey?: string,\n    parentKey?: string,\n    relatedKey?: string\n  ): import('@/Database/Ensemble/Relations/MorphedByMany').MorphedByMany<TRelated, any> {\n    const instance = new related();\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const { MorphedByMany } = require('@/Database/Ensemble/Relations/MorphedByMany');\n\n    const finalTable = table || `${name}s`;\n    const finalForeignPivotKey = foreignPivotKey || `${name}_id`;\n    const finalRelatedPivotKey = relatedPivotKey || instance.getForeignKey();\n    const morphType = `${name}_type`;\n    const finalParentKey = parentKey || (this as any).getKeyName();\n    const finalRelatedKey = relatedKey || instance.getKeyName();\n\n    return new MorphedByMany(\n      instance.newQuery() as EnsembleBuilder<TRelated>,\n      this as any,\n      name,\n      finalTable,\n      finalForeignPivotKey,\n      finalRelatedPivotKey,\n      morphType,\n      finalParentKey,\n      finalRelatedKey,\n      ''\n    );\n  }\n\n  /**\n   * Get the joining table name for a many-to-many relation\n   */\n  protected joiningTable(related: Ensemble): string {\n    const models = [this.snake((this as any).constructor.name), this.snake(related.constructor.name)];\n\n    // Sort the model names alphabetically\n    models.sort();\n\n    return models.join('_');\n  }\n\n  /**\n   * Get the default foreign key name for the model\n   */\n  protected getForeignKey(): string {\n    return this.snake((this as any).constructor.name) + '_' + (this as any).getKeyName();\n  }\n\n  /**\n   * Get a relationship value from a method\n   */\n  protected getRelationshipFromMethod(method: string): any {\n    const relation = (this as any)[method]();\n\n    if (!(relation instanceof Relation)) {\n      throw new Error(`Relationship method must return an object of type Relation (${method})`);\n    }\n\n    return relation;\n  }\n\n  /**\n   * Get a relationship instance by name\n   */\n  public getRelation(relation: string): any {\n    return this.relations[relation];\n  }\n\n  /**\n   * Set the given relationship on the model\n   */\n  public setRelation(relation: string, value: any): this {\n    this.relations[relation] = value;\n    return this as any;\n  }\n\n  /**\n   * Unset a loaded relationship\n   */\n  public unsetRelation(relation: string): this {\n    delete this.relations[relation];\n    return this as any;\n  }\n\n  /**\n   * Get all the loaded relations for the instance\n   */\n  public getRelations(): Record<string, any> {\n    return this.relations;\n  }\n\n  /**\n   * Set the entire relations array on the model\n   */\n  public setRelations(relations: Record<string, any>): this {\n    this.relations = relations;\n    return this as any;\n  }\n\n  /**\n   * Determine if the given relation is loaded\n   */\n  public relationLoaded(key: string): boolean {\n    return key in this.relations;\n  }\n\n  /**\n   * Load a relationship if it hasn't been loaded yet\n   */\n  public async load(relations: string | string[]): Promise<this> {\n    const relationArray = Array.isArray(relations) ? relations : [relations];\n\n    for (const relation of relationArray) {\n      if (!this.relationLoaded(relation)) {\n        const results = await this.getRelationshipFromMethod(relation).getResults();\n        this.setRelation(relation, results);\n      }\n    }\n\n    return this as any;\n  }\n\n  /**\n   * Eager load relations on the model\n   */\n  public async loadMissing(relations: string | string[]): Promise<this> {\n    const relationArray = Array.isArray(relations) ? relations : [relations];\n    const missing = relationArray.filter((relation) => !this.relationLoaded(relation));\n\n    if (missing.length > 0) {\n      await this.load(missing);\n    }\n\n    return this as any;\n  }\n\n  /**\n   * Touch the owning relations of the model\n   */\n  public async touch(): Promise<boolean> {\n    // TODO: Implement when we have timestamps\n    return true;\n  }\n\n  /**\n   * Create a new model query instance for the model\n   */\n  protected abstract newQuery(): EnsembleBuilder<any>;\n\n  /**\n   * Get the table name (from Ensemble)\n   */\n  protected abstract getTable(): string;\n\n  /**\n   * Get the primary key name (from Ensemble)\n   */\n  protected abstract getKeyName(): string;\n\n  /**\n   * Convert a string to snake case\n   */\n  protected snake(value: string): string {\n    return value\n      .replace(/([A-Z])/g, '_$1')\n      .toLowerCase()\n      .replace(/^_/, '');\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,39 @@
+//#region src/Database/Ensemble/Concerns/HasTimestamps.d.ts
+/**
+ * HasTimestamps Concern
+ *
+ * Provides timestamp handling functionality for models
+ */
+interface HasTimestamps {
+  /**
+   * Indicates if the model should be timestamped
+   */
+  timestamps: boolean;
+  /**
+   * Update the model's timestamps
+   */
+  updateTimestamps(): void;
+  /**
+   * Set the value of the "created at" attribute
+   */
+  setCreatedAt(value: Date): void;
+  /**
+   * Set the value of the "updated at" attribute
+   */
+  setUpdatedAt(value: Date): void;
+  /**
+   * Get the name of the "created at" column
+   */
+  getCreatedAtColumn(): string;
+  /**
+   * Get the name of the "updated at" column
+   */
+  getUpdatedAtColumn(): string;
+  /**
+   * Determine if the model uses timestamps
+   */
+  usesTimestamps(): boolean;
+}
+//#endregion
+export { HasTimestamps };
+//# sourceMappingURL=HasTimestamps.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HasTimestamps.d.cts","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasTimestamps.ts"],"mappings":";;AAMA;;;;UAAiB,aAAA;EASf;;;EALA,UAAA;EAeA;;;EAVA,gBAAA;EAoBA;;;EAfA,YAAA,CAAa,KAAA,EAAO,IAAA;;;;EAKpB,YAAA,CAAa,KAAA,EAAO,IAAA;;;;EAKpB,kBAAA;;;;EAKA,kBAAA;;;;EAKA,cAAA;AAAA"}

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

@@ -0,0 +1,39 @@
+//#region src/Database/Ensemble/Concerns/HasTimestamps.d.ts
+/**
+ * HasTimestamps Concern
+ *
+ * Provides timestamp handling functionality for models
+ */
+interface HasTimestamps {
+  /**
+   * Indicates if the model should be timestamped
+   */
+  timestamps: boolean;
+  /**
+   * Update the model's timestamps
+   */
+  updateTimestamps(): void;
+  /**
+   * Set the value of the "created at" attribute
+   */
+  setCreatedAt(value: Date): void;
+  /**
+   * Set the value of the "updated at" attribute
+   */
+  setUpdatedAt(value: Date): void;
+  /**
+   * Get the name of the "created at" column
+   */
+  getCreatedAtColumn(): string;
+  /**
+   * Get the name of the "updated at" column
+   */
+  getUpdatedAtColumn(): string;
+  /**
+   * Determine if the model uses timestamps
+   */
+  usesTimestamps(): boolean;
+}
+//#endregion
+export { HasTimestamps };
+//# sourceMappingURL=HasTimestamps.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HasTimestamps.d.mts","names":[],"sources":["../../../../src/Database/Ensemble/Concerns/HasTimestamps.ts"],"mappings":";;AAMA;;;;UAAiB,aAAA;EASf;;;EALA,UAAA;EAeA;;;EAVA,gBAAA;EAoBA;;;EAfA,YAAA,CAAa,KAAA,EAAO,IAAA;;;;EAKpB,YAAA,CAAa,KAAA,EAAO,IAAA;;;;EAKpB,kBAAA;;;;EAKA,kBAAA;;;;EAKA,cAAA;AAAA"}

package/dist/Database/Ensemble/Ensemble.cjs

@@ -0,0 +1 @@
+require(`../../_virtual/_rolldown/runtime.cjs`);const e=require(`./Concerns/HasRelationships.cjs`),t=require(`./EnsembleBuilder.cjs`),n=require(`./Events/ModelRetrieved.cjs`),r=require(`./Events/ModelCreating.cjs`),i=require(`./Events/ModelCreated.cjs`),a=require(`./Events/ModelUpdating.cjs`),o=require(`./Events/ModelUpdated.cjs`),s=require(`./Events/ModelSaving.cjs`),c=require(`./Events/ModelSaved.cjs`),l=require(`./Events/ModelDeleting.cjs`),u=require(`./Events/ModelDeleted.cjs`);var d=class d extends e.HasRelationshipsMixin{static connectionResolver;table;primaryKey=`id`;incrementing=!0;keyType=`int`;fillable=[];guarded=[`*`];static fillable;static guarded;hidden=[];visible=[];appends=[];casts={};timestamps=!0;static CREATED_AT=`created_at`;static UPDATED_AT=`updated_at`;static DELETED_AT=`deleted_at`;attributes={};original={};exists=!1;wasRecentlyCreated=!1;connection;dynamicRelations=!1;constructor(e={},t=!1){super(),t?this.setRawAttributes(e):this.fill(e)}fill(e){for(let[t,n]of Object.entries(e))this.isFillable(t)&&this.setAttribute(t,n);return this}setAttribute(e,t){let n=`set${this.studly(e)}Attribute`;return typeof this[n]==`function`?(this[n](t),this):(this.attributes[e]=t,this)}setRawAttributes(e){return this.attributes=e,this}getAttribute(e){if(!e)return;let t=`get${this.studly(e)}Attribute`;if(typeof this[t]==`function`)return this[t]();let n=this.attributes[e];return this.hasCast(e)?this.castAttribute(e,n):n}isFillable(e){let t=this.constructor,n=(Object.prototype.hasOwnProperty.call(t,`fillable`)?t.fillable:void 0)??this.fillable;if(n.length>0)return n.includes(e);let r=(Object.prototype.hasOwnProperty.call(t,`guarded`)?t.guarded:void 0)??this.guarded;return r.length>0&&!r.includes(`*`)?!r.includes(e):r[0]!==`*`}hasGetMutator(e){return typeof this[`get${this.studly(e)}Attribute`]==`function`}hasSetMutator(e){return typeof this[`set${this.studly(e)}Attribute`]==`function`}hasCast(e){return e in this.casts}castAttribute(e,t){if(t===null)return t;switch(this.casts[e]){case`int`:case`integer`:return parseInt(t);case`real`:case`float`:case`double`:return parseFloat(t);case`string`:return String(t);case`bool`:case`boolean`:return!!t;case`object`:return typeof t==`string`?JSON.parse(t):t;case`array`:case`json`:return typeof t==`string`?JSON.parse(t):t;case`collection`:return typeof t==`string`?JSON.parse(t):t;case`date`:case`datetime`:case`timestamp`:return t instanceof Date?t:new Date(t);default:return t}}toObject(){let e={};for(let t of Object.keys(this.attributes))this.isVisible(t)&&(e[t]=this.getAttribute(t));for(let t of this.appends)e[t]=this.getAttribute(t);for(let[t,n]of Object.entries(this.relations))Array.isArray(n)?e[t]=n.map(e=>e.toObject()):n&&typeof n.toObject==`function`?e[t]=n.toObject():e[t]=n;return e}toJSON(){return this.toObject()}isVisible(e){return this.visible.length>0?this.visible.includes(e):!this.hidden.includes(e)}getTable(){if(this.table)return this.table;let e=this.constructor.name;return this.pluralize(this.snake(e))}getKeyName(){return this.primaryKey}getKey(){return this.getAttribute(this.getKeyName())}static setConnectionResolver(e){d.connectionResolver=e}getConnection(){return this.constructor.connectionResolver.connection(this.connection)}static query(){let e=new this;return new t.EnsembleBuilder(e.getConnection().getAdapter(),e)}static async all(e=[`*`]){return this.query().select(...e).get()}static async find(e,t=[`*`]){return this.query().select(...t).find(e)}static async findOrFail(e,t=[`*`]){let n=await this.find(e,t);if(!n)throw Error(`Ensemble not found with id: ${e}`);return n}static async findMany(e,t=[`*`]){let n=new this;return this.query().select(...t).whereIn(n.getKeyName(),e).get()}static async create(e){let t=new this(e);return await t.save(),t}static async updateOrCreate(e,t={}){let n=await this.query().where(e).first();return n?(n.fill(t),await n.save(),n):this.create({...e,...t})}async save(){return await this.fireModelEvent(`saving`)===!1?!1:this.exists?this.performUpdate():this.performInsert()}async performInsert(){if(await this.fireModelEvent(`creating`)===!1)return!1;let e=this.getAttributesForInsert();this.timestamps&&this.updateTimestamps();let t=this.getConnection(),n=this.getTable(),r=await t.table(n).insertGetId(e);return this.incrementing&&this.setAttribute(this.getKeyName(),r),this.exists=!0,this.wasRecentlyCreated=!0,this.syncOriginal(),await this.fireModelEvent(`created`),await this.fireModelEvent(`saved`),!0}async performUpdate(){let e=this.getDirty();if(Object.keys(e).length===0)return!0;if(await this.fireModelEvent(`updating`)===!1)return!1;this.timestamps&&this.updateTimestamps();let t=this.getConnection(),n=this.getTable();return await t.table(n).where(this.getKeyName(),`=`,this.getKey()).update(e),this.syncOriginal(),await this.fireModelEvent(`updated`),await this.fireModelEvent(`saved`),!0}updateTimestamps(){let e=new Date,t=this.constructor.UPDATED_AT;t&&!this.isDirty(t)&&this.setAttribute(t,e);let n=this.constructor.CREATED_AT;!this.exists&&n&&!this.isDirty(n)&&this.setAttribute(n,e)}getDirty(){let e={};for(let[t,n]of Object.entries(this.attributes))this.originalIsEquivalent(t,n)||(e[t]=n);return e}isDirty(e){return e?e in this.getDirty():Object.keys(this.getDirty()).length>0}originalIsEquivalent(e,t){if(!(e in this.original))return!1;let n=this.original[e];return t===n?!0:t===null?!1:this.isDateAttribute(e)?this.compareDates(t,n):String(t)===String(n)}isDateAttribute(e){let t=this.casts[e];return t===`date`||t===`datetime`||t===`timestamp`}compareDates(e,t){let n=e instanceof Date?e:new Date(e),r=t instanceof Date?t:new Date(t);return n.getTime()===r.getTime()}getAttributesForInsert(){return{...this.attributes}}syncOriginal(){return this.original={...this.attributes},this}async delete(){if(!this.exists||await this.fireModelEvent(`deleting`)===!1)return!1;let e=this.getConnection(),t=this.getTable();return await e.table(t).where(this.getKeyName(),`=`,this.getKey()).delete(),this.exists=!1,await this.fireModelEvent(`deleted`),!0}async refresh(){if(!this.exists)return this;let e=await this.constructor.find(this.getKey());if(!e)throw Error(`Ensemble not found`);return this.attributes=e.attributes,this.syncOriginal(),this}studly(e){return e.split(`_`).map(e=>e.charAt(0).toUpperCase()+e.slice(1)).join(``)}snake(e){return e.replace(/([A-Z])/g,`_$1`).toLowerCase().replace(/^_/,``)}pluralize(e){return e.endsWith(`y`)?e.slice(0,-1)+`ies`:e.endsWith(`s`)?e+`es`:e+`s`}newQuery(){return this.constructor.query()}newInstance(e={},t=!1){let n=this.constructor,r=new n(e,t);return r.exists=t,t&&r.syncOriginal(),r}getUpdatedAtColumn(){return this.timestamps?this.constructor.UPDATED_AT:null}getCreatedAtColumn(){return this.timestamps?this.constructor.CREATED_AT:null}async fireModelEvent(e){let t;try{let{Dispatcher:e}=await Promise.resolve().then(()=>require(`../../Events/Dispatcher.cjs`)),{Facade:n}=await Promise.resolve().then(()=>require(`../../Support/Facade.cjs`));try{t=n.getFacadeApplication()?.make?.(`events`)}catch{}}catch{return}if(!t||typeof t.dispatch!=`function`)return;let d={retrieved:n.ModelRetrieved,creating:r.ModelCreating,created:i.ModelCreated,updating:a.ModelUpdating,updated:o.ModelUpdated,saving:s.ModelSaving,saved:c.ModelSaved,deleting:l.ModelDeleting,deleted:u.ModelDeleted}[e];if(!d)return;let f=new d(this);if([`creating`,`updating`,`saving`,`deleting`].includes(e)){if(await t.until?.(f)===!1)return!1}else await t.dispatch(f)}};exports.Ensemble=d;