chore: wip

Author: glennmichael123

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

@@ -36,6 +36,45 @@ export class BaseOrm<T, C, J> {
     return this.applySelect(params)
   }
 
+  async first(): Promise<T | undefined> {
+    const model = await this.applyFirst()
+
+    if (!model)
+      return undefined
+
+    return model as T
+  }
+
+  async firstOrFail(): Promise<T> {
+    const model = await this.applyFirstOrFail()
+
+    if (!model)
+      throw new HttpError(404, `No ${this.tableName} results found for query`)
+
+    return model as T
+  }
+
+  protected async applyFirstOrFail(): Promise<T | undefined> {
+    let model
+
+    if (this.hasSelect) {
+      model = await this.selectFromQuery.executeTakeFirst()
+    }
+    else {
+      model = await this.selectFromQuery.selectAll().executeTakeFirst()
+    }
+
+    if (!model)
+      throw new HttpError(404, `No ${this.tableName} results found for query`)
+
+    if (model) {
+      this.mapCustomGetters(model)
+      await this.loadRelations(model)
+    }
+
+    return model
+  }
+
   // The protected helper method that does the actual work
   protected async applyFind(id: number): Promise<T | undefined> {
     const model = await DB.instance.selectFrom(this.tableName)
@@ -77,6 +116,17 @@ export class BaseOrm<T, C, J> {
     return await this.applyFindMany(ids)
   }
 
+  async all(): Promise<T[]> {
+    const models = await DB.instance.selectFrom(this.tableName)
+      .selectAll()
+      .execute()
+
+    this.mapCustomGetters(models)
+    await this.loadRelations(models)
+
+    return models as T[]
+  }
+
   async applyFirst(): Promise<T | undefined> {
     let model
 
@@ -120,6 +170,32 @@ export class BaseOrm<T, C, J> {
     return await this.applyFind(id)
   }
 
+  async findOrFail(id: number): Promise<T> {
+    const model = await this.applyFindOrFail(id)
+
+    if (!model)
+      throw new HttpError(404, `No ${this.tableName} results found for id ${id}`)
+
+    return model as T
+  }
+
+  protected async applyFindOrFail(id: number): Promise<T | undefined> {
+    const model = await DB.instance.selectFrom(this.tableName)
+      .where('id', '=', id)
+      .selectAll()
+      .executeTakeFirst()
+
+    if (!model)
+      throw new HttpError(404, `No ${this.tableName} results found for id ${id}`)
+
+    this.mapCustomGetters(model)
+    await this.loadRelations(model)
+
+    cache.getOrSet(`${this.tableName}:${id}`, JSON.stringify(model))
+
+    return model
+  }
+
   applyWhereColumn(first: keyof C, operator: Operator, second: keyof C): this {
     this.selectFromQuery = this.selectFromQuery.whereRef(first, operator, second)
 
@@ -329,14 +405,67 @@ export class BaseOrm<T, C, J> {
     return model
   }
 
+  async last(): Promise<T | undefined> {
+    const model = await this.applyLast()
+
+    if (!model)
+      return undefined
+
+    return model as T
+  }
+
+  async applyGet(): Promise<T[]> {
+    let models
+
+    if (this.hasSelect) {
+      models = await this.selectFromQuery.execute()
+    }
+    else {
+      models = await this.selectFromQuery.selectAll().execute()
+    }
+
+    this.mapCustomGetters(models)
+    await this.loadRelations(models)
+
+    return models as T[]
+  }
+
+  async get(): Promise<T[]> {
+    return await this.applyGet()
+  }
+
+  skip(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  applyTake(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
+  take(count: number): this {
+    return this.applyTake(count)
+  }
+
+  async count(): Promise<number> {
+    const result = await this.selectFromQuery
+      .select(sql`COUNT(*) as count`)
+      .executeTakeFirst()
+
+    return result.count || 0
+  }
+
   applyOrderBy(column: keyof C, order: 'asc' | 'desc'): this {
     this.selectFromQuery = this.selectFromQuery.orderBy(column, order)
 
     return this
   }
 
   orderBy(column: keyof C, order: 'asc' | 'desc'): this {
-    return this.orderBy(column, order)
+    return this.applyOrderBy(column, order)
   }
 
   applyGroupBy(column: keyof C): this {

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

@@ -1231,18 +1231,10 @@ export async function generateModelString(
           await instance.applyChunk(size, callback)
         }
 
-        take(count: number): ${modelName}Model {
-          this.selectFromQuery = this.selectFromQuery.limit(count)
-
-          return this
-        }
-
         static take(count: number): ${modelName}Model {
           const instance = new ${modelName}Model(undefined)
 
-          instance.selectFromQuery = instance.selectFromQuery.limit(count)
-
-          return instance
+          return instance.applyTake(count)
         }
 
         static async pluck<K extends keyof ${modelName}Model>(field: K): Promise<${modelName}Model[K][]> {

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

@@ -454,18 +454,10 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
     await instance.applyChunk(size, callback)
   }
 
-  take(count: number): AccessTokenModel {
-    this.selectFromQuery = this.selectFromQuery.limit(count)
-
-    return this
-  }
-
   static take(count: number): AccessTokenModel {
     const instance = new AccessTokenModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.limit(count)
-
-    return instance
+    return instance.applyTake(count)
   }
 
   static async pluck<K extends keyof AccessTokenModel>(field: K): Promise<AccessTokenModel[K][]> {

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

@@ -494,18 +494,10 @@ export class CouponModel extends BaseOrm<CouponModel, CouponsTable, CouponJsonRe
     await instance.applyChunk(size, callback)
   }
 
-  take(count: number): CouponModel {
-    this.selectFromQuery = this.selectFromQuery.limit(count)
-
-    return this
-  }
-
   static take(count: number): CouponModel {
     const instance = new CouponModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.limit(count)
-
-    return instance
+    return instance.applyTake(count)
   }
 
   static async pluck<K extends keyof CouponModel>(field: K): Promise<CouponModel[K][]> {

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

@@ -439,18 +439,10 @@ export class CustomerModel extends BaseOrm<CustomerModel, CustomersTable, Custom
     await instance.applyChunk(size, callback)
   }
 
-  take(count: number): CustomerModel {
-    this.selectFromQuery = this.selectFromQuery.limit(count)
-
-    return this
-  }
-
   static take(count: number): CustomerModel {
     const instance = new CustomerModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.limit(count)
-
-    return instance
+    return instance.applyTake(count)
   }
 
   static async pluck<K extends keyof CustomerModel>(field: K): Promise<CustomerModel[K][]> {

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

@@ -424,18 +424,10 @@ export class DeploymentModel extends BaseOrm<DeploymentModel, DeploymentsTable,
     await instance.applyChunk(size, callback)
   }
 
-  take(count: number): DeploymentModel {
-    this.selectFromQuery = this.selectFromQuery.limit(count)
-
-    return this
-  }
-
   static take(count: number): DeploymentModel {
     const instance = new DeploymentModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.limit(count)
-
-    return instance
+    return instance.applyTake(count)
   }
 
   static async pluck<K extends keyof DeploymentModel>(field: K): Promise<DeploymentModel[K][]> {

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

@@ -384,18 +384,10 @@ export class ErrorModel extends BaseOrm<ErrorModel, ErrorsTable, ErrorJsonRespon
     await instance.applyChunk(size, callback)
   }
 
-  take(count: number): ErrorModel {
-    this.selectFromQuery = this.selectFromQuery.limit(count)
-
-    return this
-  }
-
   static take(count: number): ErrorModel {
     const instance = new ErrorModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.limit(count)
-
-    return instance
+    return instance.applyTake(count)
   }
 
   static async pluck<K extends keyof ErrorModel>(field: K): Promise<ErrorModel[K][]> {

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

@@ -384,18 +384,10 @@ export class FailedJobModel extends BaseOrm<FailedJobModel, FailedJobsTable, Fai
     await instance.applyChunk(size, callback)
   }
 
-  take(count: number): FailedJobModel {
-    this.selectFromQuery = this.selectFromQuery.limit(count)
-
-    return this
-  }
-
   static take(count: number): FailedJobModel {
     const instance = new FailedJobModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.limit(count)
-
-    return instance
+    return instance.applyTake(count)
   }
 
   static async pluck<K extends keyof FailedJobModel>(field: K): Promise<FailedJobModel[K][]> {

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

@@ -503,18 +503,10 @@ export class GiftCardModel extends BaseOrm<GiftCardModel, GiftCardsTable, GiftCa
     await instance.applyChunk(size, callback)
   }
 
-  take(count: number): GiftCardModel {
-    this.selectFromQuery = this.selectFromQuery.limit(count)
-
-    return this
-  }
-
   static take(count: number): GiftCardModel {
     const instance = new GiftCardModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.limit(count)
-
-    return instance
+    return instance.applyTake(count)
   }
 
   static async pluck<K extends keyof GiftCardModel>(field: K): Promise<GiftCardModel[K][]> {

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

@@ -384,18 +384,10 @@ export class JobModel extends BaseOrm<JobModel, JobsTable, JobJsonResponse> {
     await instance.applyChunk(size, callback)
   }
 
-  take(count: number): JobModel {
-    this.selectFromQuery = this.selectFromQuery.limit(count)
-
-    return this
-  }
-
   static take(count: number): JobModel {
     const instance = new JobModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.limit(count)
-
-    return instance
+    return instance.applyTake(count)
   }
 
   static async pluck<K extends keyof JobModel>(field: K): Promise<JobModel[K][]> {