chore: wip

Author: glennmichael123

storage/framework/core/orm/src/generate.ts

@@ -1596,13 +1596,11 @@ export async function generateModelString(
 
           return await instance.applyPaginate(options)
         }
-  
-        static async create(new${modelName}: New${modelName}): Promise<${modelName}Model> {
-          const instance = new ${modelName}Model(null)
 
+        async applyCreate(new${modelName}: New${modelName}): Promise<${modelName}Model> {
           const filteredValues = Object.fromEntries(
             Object.entries(new${modelName}).filter(([key]) => 
-              !instance.guarded.includes(key) && instance.fillable.includes(key)
+              !this.guarded.includes(key) && this.fillable.includes(key)
             ),
           ) as New${modelName}
 
@@ -1612,13 +1610,23 @@ export async function generateModelString(
             .values(filteredValues)
             .executeTakeFirst()
 
-          const model = await instance.find(Number(result.numInsertedOrUpdatedRows)) as ${modelName}Model
+          const model = await this.find(Number(result.numInsertedOrUpdatedRows)) as ${modelName}Model
 
           if (model)
             dispatch('${formattedModelName}:created', model)
 
           return model
         }
+        
+        async create(new${modelName}: New${modelName}): Promise<${modelName}Model> {
+          return await this.create(new${modelName})
+        }
+  
+        static async create(new${modelName}: New${modelName}): Promise<${modelName}Model> {
+          const instance = new ${modelName}Model(null)
+
+          return await instance.create(new${modelName})
+        }
   
         static async createMany(new${modelName}: New${modelName}[]): Promise<void> {
           const instance = new ${modelName}Model(null)

storage/framework/orm/src/models/AccessToken.ts

@@ -827,27 +827,35 @@ export class AccessTokenModel {
     return await instance.applyPaginate(options)
   }
 
-  static async create(newAccessToken: NewAccessToken): Promise<AccessTokenModel> {
-    const instance = new AccessTokenModel(null)
-
+  async applyCreate(newAccessToken: NewAccessToken): Promise<AccessTokenModel> {
     const filteredValues = Object.fromEntries(
       Object.entries(newAccessToken).filter(([key]) =>
-        !instance.guarded.includes(key) && instance.fillable.includes(key),
+        !this.guarded.includes(key) && this.fillable.includes(key),
       ),
     ) as NewAccessToken
 
     const result = await DB.instance.insertInto('personal_access_tokens')
       .values(filteredValues)
       .executeTakeFirst()
 
-    const model = await instance.find(Number(result.numInsertedOrUpdatedRows)) as AccessTokenModel
+    const model = await this.find(Number(result.numInsertedOrUpdatedRows)) as AccessTokenModel
 
     if (model)
       dispatch('accesstoken:created', model)
 
     return model
   }
 
+  async create(newAccessToken: NewAccessToken): Promise<AccessTokenModel> {
+    return await this.create(newAccessToken)
+  }
+
+  static async create(newAccessToken: NewAccessToken): Promise<AccessTokenModel> {
+    const instance = new AccessTokenModel(null)
+
+    return await instance.create(newAccessToken)
+  }
+
   static async createMany(newAccessToken: NewAccessToken[]): Promise<void> {
     const instance = new AccessTokenModel(null)
 

storage/framework/orm/src/models/Activity.ts

@@ -850,27 +850,35 @@ export class ActivityModel {
     return await instance.applyPaginate(options)
   }
 
-  static async create(newActivity: NewActivity): Promise<ActivityModel> {
-    const instance = new ActivityModel(null)
-
+  async applyCreate(newActivity: NewActivity): Promise<ActivityModel> {
     const filteredValues = Object.fromEntries(
       Object.entries(newActivity).filter(([key]) =>
-        !instance.guarded.includes(key) && instance.fillable.includes(key),
+        !this.guarded.includes(key) && this.fillable.includes(key),
       ),
     ) as NewActivity
 
     const result = await DB.instance.insertInto('activities')
       .values(filteredValues)
       .executeTakeFirst()
 
-    const model = await instance.find(Number(result.numInsertedOrUpdatedRows)) as ActivityModel
+    const model = await this.find(Number(result.numInsertedOrUpdatedRows)) as ActivityModel
 
     if (model)
       dispatch('activity:created', model)
 
     return model
   }
 
+  async create(newActivity: NewActivity): Promise<ActivityModel> {
+    return await this.create(newActivity)
+  }
+
+  static async create(newActivity: NewActivity): Promise<ActivityModel> {
+    const instance = new ActivityModel(null)
+
+    return await instance.create(newActivity)
+  }
+
   static async createMany(newActivity: NewActivity[]): Promise<void> {
     const instance = new ActivityModel(null)
 

storage/framework/orm/src/models/Deployment.ts

@@ -864,12 +864,10 @@ export class DeploymentModel {
     return await instance.applyPaginate(options)
   }
 
-  static async create(newDeployment: NewDeployment): Promise<DeploymentModel> {
-    const instance = new DeploymentModel(null)
-
+  async applyCreate(newDeployment: NewDeployment): Promise<DeploymentModel> {
     const filteredValues = Object.fromEntries(
       Object.entries(newDeployment).filter(([key]) =>
-        !instance.guarded.includes(key) && instance.fillable.includes(key),
+        !this.guarded.includes(key) && this.fillable.includes(key),
       ),
     ) as NewDeployment
 
@@ -879,14 +877,24 @@ export class DeploymentModel {
       .values(filteredValues)
       .executeTakeFirst()
 
-    const model = await instance.find(Number(result.numInsertedOrUpdatedRows)) as DeploymentModel
+    const model = await this.find(Number(result.numInsertedOrUpdatedRows)) as DeploymentModel
 
     if (model)
       dispatch('deployment:created', model)
 
     return model
   }
 
+  async create(newDeployment: NewDeployment): Promise<DeploymentModel> {
+    return await this.create(newDeployment)
+  }
+
+  static async create(newDeployment: NewDeployment): Promise<DeploymentModel> {
+    const instance = new DeploymentModel(null)
+
+    return await instance.create(newDeployment)
+  }
+
   static async createMany(newDeployment: NewDeployment[]): Promise<void> {
     const instance = new DeploymentModel(null)
 

storage/framework/orm/src/models/Error.ts

@@ -823,27 +823,35 @@ export class ErrorModel {
     return await instance.applyPaginate(options)
   }
 
-  static async create(newError: NewError): Promise<ErrorModel> {
-    const instance = new ErrorModel(null)
-
+  async applyCreate(newError: NewError): Promise<ErrorModel> {
     const filteredValues = Object.fromEntries(
       Object.entries(newError).filter(([key]) =>
-        !instance.guarded.includes(key) && instance.fillable.includes(key),
+        !this.guarded.includes(key) && this.fillable.includes(key),
       ),
     ) as NewError
 
     const result = await DB.instance.insertInto('errors')
       .values(filteredValues)
       .executeTakeFirst()
 
-    const model = await instance.find(Number(result.numInsertedOrUpdatedRows)) as ErrorModel
+    const model = await this.find(Number(result.numInsertedOrUpdatedRows)) as ErrorModel
 
     if (model)
       dispatch('error:created', model)
 
     return model
   }
 
+  async create(newError: NewError): Promise<ErrorModel> {
+    return await this.create(newError)
+  }
+
+  static async create(newError: NewError): Promise<ErrorModel> {
+    const instance = new ErrorModel(null)
+
+    return await instance.create(newError)
+  }
+
   static async createMany(newError: NewError[]): Promise<void> {
     const instance = new ErrorModel(null)
 

storage/framework/orm/src/models/FailedJob.ts

@@ -823,27 +823,35 @@ export class FailedJobModel {
     return await instance.applyPaginate(options)
   }
 
-  static async create(newFailedJob: NewFailedJob): Promise<FailedJobModel> {
-    const instance = new FailedJobModel(null)
-
+  async applyCreate(newFailedJob: NewFailedJob): Promise<FailedJobModel> {
     const filteredValues = Object.fromEntries(
       Object.entries(newFailedJob).filter(([key]) =>
-        !instance.guarded.includes(key) && instance.fillable.includes(key),
+        !this.guarded.includes(key) && this.fillable.includes(key),
       ),
     ) as NewFailedJob
 
     const result = await DB.instance.insertInto('failed_jobs')
       .values(filteredValues)
       .executeTakeFirst()
 
-    const model = await instance.find(Number(result.numInsertedOrUpdatedRows)) as FailedJobModel
+    const model = await this.find(Number(result.numInsertedOrUpdatedRows)) as FailedJobModel
 
     if (model)
       dispatch('failedjob:created', model)
 
     return model
   }
 
+  async create(newFailedJob: NewFailedJob): Promise<FailedJobModel> {
+    return await this.create(newFailedJob)
+  }
+
+  static async create(newFailedJob: NewFailedJob): Promise<FailedJobModel> {
+    const instance = new FailedJobModel(null)
+
+    return await instance.create(newFailedJob)
+  }
+
   static async createMany(newFailedJob: NewFailedJob[]): Promise<void> {
     const instance = new FailedJobModel(null)
 

storage/framework/orm/src/models/Job.ts

@@ -823,27 +823,35 @@ export class JobModel {
     return await instance.applyPaginate(options)
   }
 
-  static async create(newJob: NewJob): Promise<JobModel> {
-    const instance = new JobModel(null)
-
+  async applyCreate(newJob: NewJob): Promise<JobModel> {
     const filteredValues = Object.fromEntries(
       Object.entries(newJob).filter(([key]) =>
-        !instance.guarded.includes(key) && instance.fillable.includes(key),
+        !this.guarded.includes(key) && this.fillable.includes(key),
       ),
     ) as NewJob
 
     const result = await DB.instance.insertInto('jobs')
       .values(filteredValues)
       .executeTakeFirst()
 
-    const model = await instance.find(Number(result.numInsertedOrUpdatedRows)) as JobModel
+    const model = await this.find(Number(result.numInsertedOrUpdatedRows)) as JobModel
 
     if (model)
       dispatch('job:created', model)
 
     return model
   }
 
+  async create(newJob: NewJob): Promise<JobModel> {
+    return await this.create(newJob)
+  }
+
+  static async create(newJob: NewJob): Promise<JobModel> {
+    const instance = new JobModel(null)
+
+    return await instance.create(newJob)
+  }
+
   static async createMany(newJob: NewJob[]): Promise<void> {
     const instance = new JobModel(null)
 

storage/framework/orm/src/models/PaymentMethod.ts

@@ -871,12 +871,10 @@ export class PaymentMethodModel {
     return await instance.applyPaginate(options)
   }
 
-  static async create(newPaymentMethod: NewPaymentMethod): Promise<PaymentMethodModel> {
-    const instance = new PaymentMethodModel(null)
-
+  async applyCreate(newPaymentMethod: NewPaymentMethod): Promise<PaymentMethodModel> {
     const filteredValues = Object.fromEntries(
       Object.entries(newPaymentMethod).filter(([key]) =>
-        !instance.guarded.includes(key) && instance.fillable.includes(key),
+        !this.guarded.includes(key) && this.fillable.includes(key),
       ),
     ) as NewPaymentMethod
 
@@ -886,14 +884,24 @@ export class PaymentMethodModel {
       .values(filteredValues)
       .executeTakeFirst()
 
-    const model = await instance.find(Number(result.numInsertedOrUpdatedRows)) as PaymentMethodModel
+    const model = await this.find(Number(result.numInsertedOrUpdatedRows)) as PaymentMethodModel
 
     if (model)
       dispatch('paymentmethod:created', model)
 
     return model
   }
 
+  async create(newPaymentMethod: NewPaymentMethod): Promise<PaymentMethodModel> {
+    return await this.create(newPaymentMethod)
+  }
+
+  static async create(newPaymentMethod: NewPaymentMethod): Promise<PaymentMethodModel> {
+    const instance = new PaymentMethodModel(null)
+
+    return await instance.create(newPaymentMethod)
+  }
+
   static async createMany(newPaymentMethod: NewPaymentMethod[]): Promise<void> {
     const instance = new PaymentMethodModel(null)
 

storage/framework/orm/src/models/Post.ts

@@ -809,27 +809,35 @@ export class PostModel {
     return await instance.applyPaginate(options)
   }
 
-  static async create(newPost: NewPost): Promise<PostModel> {
-    const instance = new PostModel(null)
-
+  async applyCreate(newPost: NewPost): Promise<PostModel> {
     const filteredValues = Object.fromEntries(
       Object.entries(newPost).filter(([key]) =>
-        !instance.guarded.includes(key) && instance.fillable.includes(key),
+        !this.guarded.includes(key) && this.fillable.includes(key),
       ),
     ) as NewPost
 
     const result = await DB.instance.insertInto('posts')
       .values(filteredValues)
       .executeTakeFirst()
 
-    const model = await instance.find(Number(result.numInsertedOrUpdatedRows)) as PostModel
+    const model = await this.find(Number(result.numInsertedOrUpdatedRows)) as PostModel
 
     if (model)
       dispatch('post:created', model)
 
     return model
   }
 
+  async create(newPost: NewPost): Promise<PostModel> {
+    return await this.create(newPost)
+  }
+
+  static async create(newPost: NewPost): Promise<PostModel> {
+    const instance = new PostModel(null)
+
+    return await instance.create(newPost)
+  }
+
   static async createMany(newPost: NewPost[]): Promise<void> {
     const instance = new PostModel(null)