chore: wip

Author: glennmichael123

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

@@ -913,7 +913,19 @@ export async function generateModelString(
           const model = await this.selectFromQuery.selectAll().execute()
           return model.map((modelItem: ${modelName}Model) => modelItem[field])
         }
-  
+
+        async max(field: keyof ${modelName}Model): Promise<number> {
+          return await this.selectFromQuery
+            .select(sql\`MAX(\${sql.raw(field as string)}) \`)
+            .executeTakeFirst()
+        }
+         
+        async min(field: keyof ${modelName}Model): Promise<number> {
+          return await this.selectFromQuery
+            .select(sql\`MIN(\${sql.raw(field as string)}) \`)
+            .executeTakeFirst()
+        }
+            
         static async get(): Promise<${modelName}Model[]> {
           const instance = new ${modelName}Model(null)
   

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

@@ -249,6 +249,18 @@ export class AccessTokenModel {
     return model.map((modelItem: AccessTokenModel) => modelItem[field])
   }
 
+  async max(field: keyof AccessTokenModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MAX(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
+  async min(field: keyof AccessTokenModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MIN(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
   static async get(): Promise<AccessTokenModel[]> {
     const instance = new AccessTokenModel(null)
 

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

@@ -262,6 +262,18 @@ export class DeploymentModel {
     return model.map((modelItem: DeploymentModel) => modelItem[field])
   }
 
+  async max(field: keyof DeploymentModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MAX(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
+  async min(field: keyof DeploymentModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MIN(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
   static async get(): Promise<DeploymentModel[]> {
     const instance = new DeploymentModel(null)
 

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

@@ -239,6 +239,18 @@ export class ErrorModel {
     return model.map((modelItem: ErrorModel) => modelItem[field])
   }
 
+  async max(field: keyof ErrorModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MAX(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
+  async min(field: keyof ErrorModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MIN(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
   static async get(): Promise<ErrorModel[]> {
     const instance = new ErrorModel(null)
 

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

@@ -239,6 +239,18 @@ export class FailedJobModel {
     return model.map((modelItem: FailedJobModel) => modelItem[field])
   }
 
+  async max(field: keyof FailedJobModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MAX(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
+  async min(field: keyof FailedJobModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MIN(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
   static async get(): Promise<FailedJobModel[]> {
     const instance = new FailedJobModel(null)
 

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

@@ -239,6 +239,18 @@ export class JobModel {
     return model.map((modelItem: JobModel) => modelItem[field])
   }
 
+  async max(field: keyof JobModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MAX(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
+  async min(field: keyof JobModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MIN(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
   static async get(): Promise<JobModel[]> {
     const instance = new JobModel(null)
 

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

@@ -272,6 +272,18 @@ export class PaymentMethodModel {
     return model.map((modelItem: PaymentMethodModel) => modelItem[field])
   }
 
+  async max(field: keyof PaymentMethodModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MAX(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
+  async min(field: keyof PaymentMethodModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MIN(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
   static async get(): Promise<PaymentMethodModel[]> {
     const instance = new PaymentMethodModel(null)
 

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

@@ -243,6 +243,18 @@ export class PostModel {
     return model.map((modelItem: PostModel) => modelItem[field])
   }
 
+  async max(field: keyof PostModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MAX(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
+  async min(field: keyof PostModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MIN(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
   static async get(): Promise<PostModel[]> {
     const instance = new PostModel(null)
 

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

@@ -249,6 +249,18 @@ export class ProductModel {
     return model.map((modelItem: ProductModel) => modelItem[field])
   }
 
+  async max(field: keyof ProductModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MAX(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
+  async min(field: keyof ProductModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MIN(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
   static async get(): Promise<ProductModel[]> {
     const instance = new ProductModel(null)
 

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

@@ -236,6 +236,18 @@ export class ProjectModel {
     return model.map((modelItem: ProjectModel) => modelItem[field])
   }
 
+  async max(field: keyof ProjectModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MAX(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
+  async min(field: keyof ProjectModel): Promise<number> {
+    return await this.selectFromQuery
+      .select(sql`MIN(${sql.raw(field as string)}) `)
+      .executeTakeFirst()
+  }
+
   static async get(): Promise<ProjectModel[]> {
     const instance = new ProjectModel(null)