chore: wip

Author: glennmichael123

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

@@ -1195,8 +1195,8 @@ export async function generateModelString(
             .select(sql\`SUM(\${sql.raw(field as string)})\`)
             .executeTakeFirst()
         }
-
-        async get(): Promise<${modelName}Model[]> {
+        
+        async applyGet(): Promise<${modelName}Model[]> {
           let models
         
           if (this.hasSelect) {
@@ -1216,30 +1216,14 @@ export async function generateModelString(
           return data
         }
 
+        async get(): Promise<${modelName}Model[]> {
+          return await this.applyGet()
+        }
+
         static async get(): Promise<${modelName}Model[]> {
           const instance = new ${modelName}Model(null)
-  
-          let models
-        
-          if (instance.hasSelect) {
-            ${instanceSoftDeleteStatementsSelectFrom}
-  
-            models = await instance.selectFromQuery.execute()
-          } else {
-            ${instanceSoftDeleteStatementsSelectFrom}
-  
-            models = await instance.selectFromQuery.selectAll().execute()
-          }
-  
-          const data = await Promise.all(models.map(async (model: ${modelName}Model) => {
-            const instance = new ${modelName}Model(model)
-  
-            const results = await instance.mapWith(model)
-  
-            return new ${modelName}Model(results)
-          }))
-          
-          return data
+
+          return await instance.applyGet()
         }
 
         has(relation: string): ${modelName}Model {

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

@@ -423,7 +423,7 @@ export class AccessTokenModel {
       .executeTakeFirst()
   }
 
-  async get(): Promise<AccessTokenModel[]> {
+  async applyGet(): Promise<AccessTokenModel[]> {
     let models
 
     if (this.hasSelect) {
@@ -444,27 +444,14 @@ export class AccessTokenModel {
     return data
   }
 
+  async get(): Promise<AccessTokenModel[]> {
+    return await this.applyGet()
+  }
+
   static async get(): Promise<AccessTokenModel[]> {
     const instance = new AccessTokenModel(null)
 
-    let models
-
-    if (instance.hasSelect) {
-      models = await instance.selectFromQuery.execute()
-    }
-    else {
-      models = await instance.selectFromQuery.selectAll().execute()
-    }
-
-    const data = await Promise.all(models.map(async (model: AccessTokenModel) => {
-      const instance = new AccessTokenModel(model)
-
-      const results = await instance.mapWith(model)
-
-      return new AccessTokenModel(results)
-    }))
-
-    return data
+    return await instance.applyGet()
   }
 
   has(relation: string): AccessTokenModel {

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

@@ -442,7 +442,7 @@ export class ActivityModel {
       .executeTakeFirst()
   }
 
-  async get(): Promise<ActivityModel[]> {
+  async applyGet(): Promise<ActivityModel[]> {
     let models
 
     if (this.hasSelect) {
@@ -463,35 +463,14 @@ export class ActivityModel {
     return data
   }
 
+  async get(): Promise<ActivityModel[]> {
+    return await this.applyGet()
+  }
+
   static async get(): Promise<ActivityModel[]> {
     const instance = new ActivityModel(null)
 
-    let models
-
-    if (instance.hasSelect) {
-      if (instance.softDeletes) {
-        instance.selectFromQuery = instance.selectFromQuery.where('deleted_at', 'is', null)
-      }
-
-      models = await instance.selectFromQuery.execute()
-    }
-    else {
-      if (instance.softDeletes) {
-        instance.selectFromQuery = instance.selectFromQuery.where('deleted_at', 'is', null)
-      }
-
-      models = await instance.selectFromQuery.selectAll().execute()
-    }
-
-    const data = await Promise.all(models.map(async (model: ActivityModel) => {
-      const instance = new ActivityModel(model)
-
-      const results = await instance.mapWith(model)
-
-      return new ActivityModel(results)
-    }))
-
-    return data
+    return await instance.applyGet()
   }
 
   has(relation: string): ActivityModel {

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

@@ -460,7 +460,7 @@ export class DeploymentModel {
       .executeTakeFirst()
   }
 
-  async get(): Promise<DeploymentModel[]> {
+  async applyGet(): Promise<DeploymentModel[]> {
     let models
 
     if (this.hasSelect) {
@@ -481,27 +481,14 @@ export class DeploymentModel {
     return data
   }
 
+  async get(): Promise<DeploymentModel[]> {
+    return await this.applyGet()
+  }
+
   static async get(): Promise<DeploymentModel[]> {
     const instance = new DeploymentModel(null)
 
-    let models
-
-    if (instance.hasSelect) {
-      models = await instance.selectFromQuery.execute()
-    }
-    else {
-      models = await instance.selectFromQuery.selectAll().execute()
-    }
-
-    const data = await Promise.all(models.map(async (model: DeploymentModel) => {
-      const instance = new DeploymentModel(model)
-
-      const results = await instance.mapWith(model)
-
-      return new DeploymentModel(results)
-    }))
-
-    return data
+    return await instance.applyGet()
   }
 
   has(relation: string): DeploymentModel {

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

@@ -415,7 +415,7 @@ export class ErrorModel {
       .executeTakeFirst()
   }
 
-  async get(): Promise<ErrorModel[]> {
+  async applyGet(): Promise<ErrorModel[]> {
     let models
 
     if (this.hasSelect) {
@@ -436,27 +436,14 @@ export class ErrorModel {
     return data
   }
 
+  async get(): Promise<ErrorModel[]> {
+    return await this.applyGet()
+  }
+
   static async get(): Promise<ErrorModel[]> {
     const instance = new ErrorModel(null)
 
-    let models
-
-    if (instance.hasSelect) {
-      models = await instance.selectFromQuery.execute()
-    }
-    else {
-      models = await instance.selectFromQuery.selectAll().execute()
-    }
-
-    const data = await Promise.all(models.map(async (model: ErrorModel) => {
-      const instance = new ErrorModel(model)
-
-      const results = await instance.mapWith(model)
-
-      return new ErrorModel(results)
-    }))
-
-    return data
+    return await instance.applyGet()
   }
 
   has(relation: string): ErrorModel {

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

@@ -415,7 +415,7 @@ export class FailedJobModel {
       .executeTakeFirst()
   }
 
-  async get(): Promise<FailedJobModel[]> {
+  async applyGet(): Promise<FailedJobModel[]> {
     let models
 
     if (this.hasSelect) {
@@ -436,27 +436,14 @@ export class FailedJobModel {
     return data
   }
 
+  async get(): Promise<FailedJobModel[]> {
+    return await this.applyGet()
+  }
+
   static async get(): Promise<FailedJobModel[]> {
     const instance = new FailedJobModel(null)
 
-    let models
-
-    if (instance.hasSelect) {
-      models = await instance.selectFromQuery.execute()
-    }
-    else {
-      models = await instance.selectFromQuery.selectAll().execute()
-    }
-
-    const data = await Promise.all(models.map(async (model: FailedJobModel) => {
-      const instance = new FailedJobModel(model)
-
-      const results = await instance.mapWith(model)
-
-      return new FailedJobModel(results)
-    }))
-
-    return data
+    return await instance.applyGet()
   }
 
   has(relation: string): FailedJobModel {

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

@@ -415,7 +415,7 @@ export class JobModel {
       .executeTakeFirst()
   }
 
-  async get(): Promise<JobModel[]> {
+  async applyGet(): Promise<JobModel[]> {
     let models
 
     if (this.hasSelect) {
@@ -436,27 +436,14 @@ export class JobModel {
     return data
   }
 
+  async get(): Promise<JobModel[]> {
+    return await this.applyGet()
+  }
+
   static async get(): Promise<JobModel[]> {
     const instance = new JobModel(null)
 
-    let models
-
-    if (instance.hasSelect) {
-      models = await instance.selectFromQuery.execute()
-    }
-    else {
-      models = await instance.selectFromQuery.selectAll().execute()
-    }
-
-    const data = await Promise.all(models.map(async (model: JobModel) => {
-      const instance = new JobModel(model)
-
-      const results = await instance.mapWith(model)
-
-      return new JobModel(results)
-    }))
-
-    return data
+    return await instance.applyGet()
   }
 
   has(relation: string): JobModel {

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

@@ -473,7 +473,7 @@ export class PaymentMethodModel {
       .executeTakeFirst()
   }
 
-  async get(): Promise<PaymentMethodModel[]> {
+  async applyGet(): Promise<PaymentMethodModel[]> {
     let models
 
     if (this.hasSelect) {
@@ -494,27 +494,14 @@ export class PaymentMethodModel {
     return data
   }
 
+  async get(): Promise<PaymentMethodModel[]> {
+    return await this.applyGet()
+  }
+
   static async get(): Promise<PaymentMethodModel[]> {
     const instance = new PaymentMethodModel(null)
 
-    let models
-
-    if (instance.hasSelect) {
-      models = await instance.selectFromQuery.execute()
-    }
-    else {
-      models = await instance.selectFromQuery.selectAll().execute()
-    }
-
-    const data = await Promise.all(models.map(async (model: PaymentMethodModel) => {
-      const instance = new PaymentMethodModel(model)
-
-      const results = await instance.mapWith(model)
-
-      return new PaymentMethodModel(results)
-    }))
-
-    return data
+    return await instance.applyGet()
   }
 
   has(relation: string): PaymentMethodModel {

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

@@ -405,7 +405,7 @@ export class PostModel {
       .executeTakeFirst()
   }
 
-  async get(): Promise<PostModel[]> {
+  async applyGet(): Promise<PostModel[]> {
     let models
 
     if (this.hasSelect) {
@@ -426,27 +426,14 @@ export class PostModel {
     return data
   }
 
+  async get(): Promise<PostModel[]> {
+    return await this.applyGet()
+  }
+
   static async get(): Promise<PostModel[]> {
     const instance = new PostModel(null)
 
-    let models
-
-    if (instance.hasSelect) {
-      models = await instance.selectFromQuery.execute()
-    }
-    else {
-      models = await instance.selectFromQuery.selectAll().execute()
-    }
-
-    const data = await Promise.all(models.map(async (model: PostModel) => {
-      const instance = new PostModel(model)
-
-      const results = await instance.mapWith(model)
-
-      return new PostModel(results)
-    }))
-
-    return data
+    return await instance.applyGet()
   }
 
   has(relation: string): PostModel {