feat(relationships): add create and createMany methods

adonis-typings/model.ts

@@ -265,6 +265,16 @@ declare module '@ioc:Adonis/Lucid/Model' {
      * Save the related model.
      */
     saveMany (model: T[], wrapInTransaction?: boolean): Promise<void>
+
+    /**
+     * Create the related model instance
+     */
+    create (values: ModelObject, wrapInTransaction?: boolean): Promise<T>
+
+    /**
+     * Create many of the related model instance
+     */
+    createMany (values: ModelObject[], wrapInTransaction?: boolean): Promise<T[]>
   }
 
   /**
@@ -354,6 +364,16 @@ declare module '@ioc:Adonis/Lucid/Model' {
      */
     saveMany (model: T[], wrapInTransaction?: boolean, checkExisting?: boolean): Promise<void>
 
+    /**
+     * Create the related model instance
+     */
+    create (values: ModelObject, wrapInTransaction?: boolean, checkExisting?: boolean): Promise<T>
+
+    /**
+     * Create many of the related model instance
+     */
+    createMany (values: ModelObject, wrapInTransaction?: boolean, checkExisting?: boolean): Promise<T[]>
+
     /**
      * Attach related
      */

src/Orm/Relations/Base/QueryBuilder.ts

@@ -20,6 +20,7 @@
 import knex from 'knex'
 
 import {
+  ModelObject,
   ModelContract,
   RelationContract,
   BaseRelationQueryBuilderContract,
@@ -139,4 +140,6 @@ export abstract class BaseRelationQueryBuilder
 
   public abstract async save (model: ModelContract, wrapInTransaction?: boolean): Promise<void>
   public abstract async saveMany (model: ModelContract[], wrapInTransaction?: boolean): Promise<void>
+  public abstract async create (model: ModelObject, wrapInTransaction?: boolean): Promise<ModelContract>
+  public abstract async createMany (model: ModelObject[], wrapInTransaction?: boolean): Promise<ModelContract[]>
 }

src/Orm/Relations/BelongsTo/QueryBuilder.ts

@@ -12,7 +12,7 @@
 import knex from 'knex'
 import { Exception } from '@poppinss/utils'
 
-import { ModelContract, BelongsToQueryBuilderContract } from '@ioc:Adonis/Lucid/Model'
+import { ModelContract, BelongsToQueryBuilderContract, ModelObject } from '@ioc:Adonis/Lucid/Model'
 import { QueryClientContract, TransactionClientContract } from '@ioc:Adonis/Lucid/Database'
 
 import { BelongsTo } from './index'
@@ -151,4 +151,22 @@ export class BelongsToQueryBuilder
   public saveMany (): Promise<void> {
     throw new Exception(`Cannot save many of ${this._relation.model.name}.${this._relation.relationName}. Use associate instead.`)
   }
+
+  /**
+   * Alias for save, since `associate` feels more natural
+   */
+  public async create (values: ModelObject, wrapInTransaction: boolean = true): Promise<any> {
+    const related = new (this._relation.relatedModel())()
+    related.fill(values)
+
+    await this.save(related, wrapInTransaction)
+    return related
+  }
+
+  /**
+   * Create many not allowed for belongsTo
+   */
+  public createMany (): Promise<any> {
+    throw new Exception(`Cannot create many of ${this._relation.model.name}.${this._relation.relationName}. Use create instead.`)
+  }
 }

src/Orm/Relations/HasMany/QueryBuilder.ts

@@ -10,7 +10,7 @@
 /// <reference path="../../../../adonis-typings/index.ts" />
 
 import knex from 'knex'
-import { HasManyQueryBuilderContract, ModelContract } from '@ioc:Adonis/Lucid/Model'
+import { HasManyQueryBuilderContract, ModelContract, ModelObject } from '@ioc:Adonis/Lucid/Model'
 import { QueryClientContract, TransactionClientContract } from '@ioc:Adonis/Lucid/Database'
 
 import { HasMany } from './index'
@@ -125,4 +125,29 @@ export class HasManyQueryBuilder
       return this.$persist(this._parent, related, callback)
     }
   }
+
+  /**
+   * Create and persist related model instance
+   */
+  public async create (values: ModelObject, wrapInTransaction: boolean = true): Promise<any> {
+    const related = new (this._relation.relatedModel())()
+    related.fill(values)
+    await this.save(related, wrapInTransaction)
+
+    return related
+  }
+
+  /**
+   * Create and persist related model instances
+   */
+  public async createMany (values: ModelObject[], wrapInTransaction: boolean = true): Promise<any> {
+    const relatedModels = values.map((value) => {
+      const related = new (this._relation.relatedModel())()
+      related.fill(value)
+      return related
+    })
+
+    await this.saveMany(relatedModels, wrapInTransaction)
+    return relatedModels
+  }
 }

src/Orm/Relations/HasManyThrough/QueryBuilder.ts

@@ -110,11 +110,19 @@ export class HasManyThroughQueryBuilder
     return this
   }
 
-  public save (): Promise<void> {
+  public async save (): Promise<void> {
     throw new Exception('Has many through doesn\'t support saving relations')
   }
 
   public async saveMany () {
     return this.save()
   }
+
+  public async create (): Promise<any> {
+    return this.save()
+  }
+
+  public async createMany (): Promise<any> {
+    return this.save()
+  }
 }

src/Orm/Relations/HasOne/QueryBuilder.ts

@@ -11,8 +11,8 @@
 
 import knex from 'knex'
 import { Exception } from '@poppinss/utils'
-import { HasOneQueryBuilderContract, ModelContract } from '@ioc:Adonis/Lucid/Model'
 import { QueryClientContract, TransactionClientContract } from '@ioc:Adonis/Lucid/Database'
+import { HasOneQueryBuilderContract, ModelContract, ModelObject } from '@ioc:Adonis/Lucid/Model'
 
 import { HasOne } from './index'
 import { unique } from '../../../utils'
@@ -103,10 +103,28 @@ export class HasOneQueryBuilder extends BaseRelationQueryBuilder implements HasO
     }
   }
 
+  /**
+   * Create and persist related model instance
+   */
+  public async create (values: ModelObject, wrapInTransaction: boolean = true): Promise<any> {
+    const related = new (this._relation.relatedModel())()
+    related.fill(values)
+    await this.save(related, wrapInTransaction)
+
+    return related
+  }
+
   /**
    * Save many is not allowed by HasOne
    */
   public saveMany (): Promise<void> {
     throw new Exception(`Cannot save many of ${this._relation.model.name}.${this._relation.relationName}. Use save instead.`)
   }
+
+  /**
+   * Save many is not allowed by HasOne
+   */
+  public createMany (): Promise<any> {
+    throw new Exception(`Cannot create many of ${this._relation.model.name}.${this._relation.relationName}. Use create instead.`)
+  }
 }

src/Orm/Relations/ManyToMany/QueryBuilder.ts

@@ -10,7 +10,7 @@
 /// <reference path="../../../../adonis-typings/index.ts" />
 
 import knex from 'knex'
-import { ModelContract, ManyToManyQueryBuilderContract } from '@ioc:Adonis/Lucid/Model'
+import { ModelContract, ManyToManyQueryBuilderContract, ModelObject } from '@ioc:Adonis/Lucid/Model'
 import { QueryClientContract, TransactionClientContract } from '@ioc:Adonis/Lucid/Database'
 
 import { ManyToMany } from './index'
@@ -627,4 +627,37 @@ export class ManyToManyQueryBuilder
       await this._sync(this._parent, ids, checkExisting)
     }
   }
+
+  /**
+   * Create and persist related model instance
+   */
+  public async create (
+    values: ModelObject,
+    wrapInTransaction: boolean = true,
+    checkExisting: boolean = true,
+  ): Promise<any> {
+    const related = new (this._relation.relatedModel())()
+    related.fill(values)
+    await this.save(related, wrapInTransaction, checkExisting)
+
+    return related
+  }
+
+  /**
+   * Create and persist related model instances
+   */
+  public async createMany (
+    values: ModelObject[],
+    wrapInTransaction: boolean = true,
+    checkExisting: boolean = true,
+  ): Promise<any> {
+    const relatedModels = values.map((value) => {
+      const related = new (this._relation.relatedModel())()
+      related.fill(value)
+      return related
+    })
+
+    await this.saveMany(relatedModels, wrapInTransaction, checkExisting)
+    return relatedModels
+  }
 }