feat: add through relations

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/database",
-  "version": "5.54.0",
+  "version": "5.55.0",
   "description": "The Athenna database handler for SQL/NoSQL.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",

src/constants/MetadataKeys.ts

@@ -10,5 +10,7 @@
 export const COLUMNS_KEY = 'database:columns:options'
 export const HAS_ONE_KEY = 'database:hasOne:options'
 export const HAS_MANY_KEY = 'database:hasMany:options'
+export const HAS_ONE_THROUGH_KEY = 'database:hasOneThrough:options'
+export const HAS_MANY_THROUGH_KEY = 'database:hasManyThrough:options'
 export const BELONGS_TO_KEY = 'database:belongsTo:options'
 export const BELONGS_TO_MANY_KEY = 'database:belongsToMany:options'

src/helpers/Annotation.ts

@@ -11,6 +11,8 @@ import {
   COLUMNS_KEY,
   HAS_ONE_KEY,
   HAS_MANY_KEY,
+  HAS_ONE_THROUGH_KEY,
+  HAS_MANY_THROUGH_KEY,
   BELONGS_TO_KEY,
   BELONGS_TO_MANY_KEY
 } from '#src/constants/MetadataKeys'
@@ -19,6 +21,8 @@ import type {
   ColumnOptions,
   HasOneOptions,
   HasManyOptions,
+  HasOneThroughOptions,
+  HasManyThroughOptions,
   BelongsToOptions,
   BelongsToManyOptions
 } from '#src/types'
@@ -40,6 +44,8 @@ export class Annotation {
     return [
       ...this.getHasOnesMeta(target),
       ...this.getHasManyMeta(target),
+      ...this.getHasOneThroughMeta(target),
+      ...this.getHasManyThroughMeta(target),
       ...this.getBelongsToMeta(target),
       ...this.getBelongsToManyMeta(target)
     ]
@@ -69,6 +75,37 @@ export class Annotation {
     Reflect.defineMetadata(HAS_MANY_KEY, hasMany, target)
   }
 
+  public static getHasOneThroughMeta(target: any): HasOneThroughOptions[] {
+    return Reflect.getMetadata(HAS_ONE_THROUGH_KEY, target) || []
+  }
+
+  public static defineHasOneThroughMeta(
+    target: any,
+    options: HasOneThroughOptions
+  ) {
+    const hasOneThrough = Reflect.getMetadata(HAS_ONE_THROUGH_KEY, target) || []
+
+    hasOneThrough.push(options)
+
+    Reflect.defineMetadata(HAS_ONE_THROUGH_KEY, hasOneThrough, target)
+  }
+
+  public static getHasManyThroughMeta(target: any): HasManyThroughOptions[] {
+    return Reflect.getMetadata(HAS_MANY_THROUGH_KEY, target) || []
+  }
+
+  public static defineHasManyThroughMeta(
+    target: any,
+    options: HasManyThroughOptions
+  ) {
+    const hasManyThrough =
+      Reflect.getMetadata(HAS_MANY_THROUGH_KEY, target) || []
+
+    hasManyThrough.push(options)
+
+    Reflect.defineMetadata(HAS_MANY_THROUGH_KEY, hasManyThrough, target)
+  }
+
   public static getBelongsToMeta(target: any): BelongsToOptions[] {
     return Reflect.getMetadata(BELONGS_TO_KEY, target) || []
   }

src/index.ts

@@ -15,6 +15,8 @@ export * from '#src/models/schemas/ModelSchema'
 export * from '#src/models/annotations/Column'
 export * from '#src/models/annotations/HasOne'
 export * from '#src/models/annotations/HasMany'
+export * from '#src/models/annotations/HasOneThrough'
+export * from '#src/models/annotations/HasManyThrough'
 export * from '#src/models/annotations/BelongsTo'
 export * from '#src/models/annotations/BelongsToMany'
 

src/models/annotations/HasManyThrough.ts

@@ -0,0 +1,66 @@
+/**
+ * @athenna/database
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import 'reflect-metadata'
+
+import { debug } from '#src/debug'
+import { Annotation } from '#src/helpers/Annotation'
+import { Is, Options } from '@athenna/common'
+import type { BaseModel } from '#src/models/BaseModel'
+import type { HasManyThroughOptions } from '#src/types/relations/HasManyThroughOptions'
+
+/**
+ * Create has many through relation for model class.
+ */
+export function HasManyThrough<
+  T extends BaseModel = any,
+  R extends BaseModel = any,
+  H extends BaseModel = any
+>(
+  model: (() => new () => R) | string,
+  through: (() => new () => H) | string,
+  options: Omit<
+    HasManyThroughOptions<T, R, H>,
+    'type' | 'model' | 'through' | 'property'
+  > = {}
+) {
+  return (target: T, key: any) => {
+    const Target = target.constructor as typeof BaseModel
+
+    options = Options.create(options, {
+      isIncluded: false,
+      inverse: false
+    })
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    options.type = 'hasManyThrough'
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    options.model = Is.String(model)
+      ? () => ioc.safeUse(`App/Models/${model}`).constructor
+      : model
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    options.through = Is.String(through)
+      ? () => ioc.safeUse(`App/Models/${through}`).constructor
+      : through
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    options.property = key
+
+    debug(
+      'registering hasManyThrough metadata for model %s: %o',
+      Target.name,
+      options
+    )
+
+    Annotation.defineHasManyThroughMeta(Target, options)
+  }
+}

src/models/annotations/HasOneThrough.ts

@@ -0,0 +1,66 @@
+/**
+ * @athenna/database
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import 'reflect-metadata'
+
+import { debug } from '#src/debug'
+import { Annotation } from '#src/helpers/Annotation'
+import { Is, Options } from '@athenna/common'
+import type { BaseModel } from '#src/models/BaseModel'
+import type { HasOneThroughOptions } from '#src/types/relations/HasOneThroughOptions'
+
+/**
+ * Create has one through relation for model class.
+ */
+export function HasOneThrough<
+  T extends BaseModel = any,
+  R extends BaseModel = any,
+  H extends BaseModel = any
+>(
+  model: (() => new () => R) | string,
+  through: (() => new () => H) | string,
+  options: Omit<
+    HasOneThroughOptions<T, R, H>,
+    'type' | 'model' | 'through' | 'property'
+  > = {}
+) {
+  return (target: T, key: any) => {
+    const Target = target.constructor as typeof BaseModel
+
+    options = Options.create(options, {
+      isIncluded: false,
+      inverse: false
+    })
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    options.type = 'hasOneThrough'
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    options.model = Is.String(model)
+      ? () => ioc.safeUse(`App/Models/${model}`).constructor
+      : model
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    options.through = Is.String(through)
+      ? () => ioc.safeUse(`App/Models/${through}`).constructor
+      : through
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    options.property = key
+
+    debug(
+      'registering hasOneThrough metadata for model %s: %o',
+      Target.name,
+      options
+    )
+
+    Annotation.defineHasOneThroughMeta(Target, options)
+  }
+}

src/models/builders/ModelQueryBuilder.ts

@@ -34,6 +34,8 @@ import { HasManyRelation } from '#src/models/relations/HasMany/HasManyRelation'
 import { NullableValueException } from '#src/exceptions/NullableValueException'
 import { BelongsToRelation } from '#src/models/relations/BelongsTo/BelongsToRelation'
 import { BelongsToManyRelation } from '#src/models/relations/BelongsToMany/BelongsToManyRelation'
+import { HasOneThroughRelation } from '#src/models/relations/HasOneThrough/HasOneThroughRelation'
+import { HasManyThroughRelation } from '#src/models/relations/HasManyThrough/HasManyThroughRelation'
 
 export class ModelQueryBuilder<
   M extends BaseModel = any,
@@ -615,6 +617,10 @@ export class ModelQueryBuilder<
           return HasOneRelation.whereHas(this.Model, query, snapshot)
         case 'hasMany':
           return HasManyRelation.whereHas(this.Model, query, snapshot)
+        case 'hasOneThrough':
+          return HasOneThroughRelation.whereHas(this.Model, query, snapshot)
+        case 'hasManyThrough':
+          return HasManyThroughRelation.whereHas(this.Model, query, snapshot)
         case 'belongsTo':
           return BelongsToRelation.whereHas(this.Model, query, snapshot)
         case 'belongsToMany':
@@ -659,6 +665,10 @@ export class ModelQueryBuilder<
           return HasOneRelation.whereHas(this.Model, query, snapshot)
         case 'hasMany':
           return HasManyRelation.whereHas(this.Model, query, snapshot)
+        case 'hasOneThrough':
+          return HasOneThroughRelation.whereHas(this.Model, query, snapshot)
+        case 'hasManyThrough':
+          return HasManyThroughRelation.whereHas(this.Model, query, snapshot)
         case 'belongsTo':
           return BelongsToRelation.whereHas(this.Model, query, snapshot)
         case 'belongsToMany':

src/models/factories/ModelGenerator.ts

@@ -14,6 +14,8 @@ import type { BaseModel } from '#src/models/BaseModel'
 import { ModelSchema } from '#src/models/schemas/ModelSchema'
 import { HasOneRelation } from '#src/models/relations/HasOne/HasOneRelation'
 import { HasManyRelation } from '#src/models/relations/HasMany/HasManyRelation'
+import { HasOneThroughRelation } from '#src/models/relations/HasOneThrough/HasOneThroughRelation'
+import { HasManyThroughRelation } from '#src/models/relations/HasManyThrough/HasManyThroughRelation'
 import { BelongsToRelation } from '#src/models/relations/BelongsTo/BelongsToRelation'
 import { BelongsToManyRelation } from '#src/models/relations/BelongsToMany/BelongsToManyRelation'
 
@@ -105,6 +107,10 @@ export class ModelGenerator<M extends BaseModel = any> extends Macroable {
         return HasOneRelation.load(model, relation)
       case 'hasMany':
         return HasManyRelation.load(model, relation)
+      case 'hasOneThrough':
+        return HasOneThroughRelation.load(model, relation)
+      case 'hasManyThrough':
+        return HasManyThroughRelation.load(model, relation)
       case 'belongsTo':
         return BelongsToRelation.load(model, relation)
       case 'belongsToMany':
@@ -147,6 +153,10 @@ export class ModelGenerator<M extends BaseModel = any> extends Macroable {
         return HasOneRelation.loadAll(models, relation)
       case 'hasMany':
         return HasManyRelation.loadAll(models, relation)
+      case 'hasOneThrough':
+        return HasOneThroughRelation.loadAll(models, relation)
+      case 'hasManyThrough':
+        return HasManyThroughRelation.loadAll(models, relation)
       case 'belongsTo':
         return BelongsToRelation.loadAll(models, relation)
       case 'belongsToMany':