chore: wip

Author: glennmichael123

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

@@ -876,6 +876,34 @@ export async function generateModelString(
           return model.map(modelItem => instance.parseResult(new ${modelName}Model(modelItem)))
         }
 
+        static skip(count: number): ${modelName}Model {
+          const instance = new ${modelName}Model(null)
+
+          instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+          return instance
+        }
+          
+        skip(count: number): ${modelName}Model {
+          this.selectFromQuery = this.selectFromQuery.offset(count)
+
+          return this
+        }
+
+        static take(count: number): ${modelName}Model {
+          const instance = new ${modelName}Model(null)
+
+          instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+          return instance
+        }
+
+        take(count: number): this {
+          this.selectFromQuery = this.selectFromQuery.limit(count)
+
+          return this
+        }
+
         async pluck<K extends keyof ${modelName}Model>(field: K): Promise<${modelName}Model[K][]> {
           if (this.hasSelect) {
             const model = await this.selectFromQuery.execute()

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

@@ -211,6 +211,34 @@ export class AccessTokenModel {
     return model.map(modelItem => instance.parseResult(new AccessTokenModel(modelItem)))
   }
 
+  static skip(count: number): AccessTokenModel {
+    const instance = new AccessTokenModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+    return instance
+  }
+
+  skip(count: number): AccessTokenModel {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  static take(count: number): AccessTokenModel {
+    const instance = new AccessTokenModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+    return instance
+  }
+
+  take(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
   async pluck<K extends keyof AccessTokenModel>(field: K): Promise<AccessTokenModel[K][]> {
     if (this.hasSelect) {
       const model = await this.selectFromQuery.execute()

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

@@ -224,6 +224,34 @@ export class DeploymentModel {
     return model.map(modelItem => instance.parseResult(new DeploymentModel(modelItem)))
   }
 
+  static skip(count: number): DeploymentModel {
+    const instance = new DeploymentModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+    return instance
+  }
+
+  skip(count: number): DeploymentModel {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  static take(count: number): DeploymentModel {
+    const instance = new DeploymentModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+    return instance
+  }
+
+  take(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
   async pluck<K extends keyof DeploymentModel>(field: K): Promise<DeploymentModel[K][]> {
     if (this.hasSelect) {
       const model = await this.selectFromQuery.execute()

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

@@ -201,6 +201,34 @@ export class ErrorModel {
     return model.map(modelItem => instance.parseResult(new ErrorModel(modelItem)))
   }
 
+  static skip(count: number): ErrorModel {
+    const instance = new ErrorModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+    return instance
+  }
+
+  skip(count: number): ErrorModel {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  static take(count: number): ErrorModel {
+    const instance = new ErrorModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+    return instance
+  }
+
+  take(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
   async pluck<K extends keyof ErrorModel>(field: K): Promise<ErrorModel[K][]> {
     if (this.hasSelect) {
       const model = await this.selectFromQuery.execute()

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

@@ -201,6 +201,34 @@ export class FailedJobModel {
     return model.map(modelItem => instance.parseResult(new FailedJobModel(modelItem)))
   }
 
+  static skip(count: number): FailedJobModel {
+    const instance = new FailedJobModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+    return instance
+  }
+
+  skip(count: number): FailedJobModel {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  static take(count: number): FailedJobModel {
+    const instance = new FailedJobModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+    return instance
+  }
+
+  take(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
   async pluck<K extends keyof FailedJobModel>(field: K): Promise<FailedJobModel[K][]> {
     if (this.hasSelect) {
       const model = await this.selectFromQuery.execute()

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

@@ -201,6 +201,34 @@ export class JobModel {
     return model.map(modelItem => instance.parseResult(new JobModel(modelItem)))
   }
 
+  static skip(count: number): JobModel {
+    const instance = new JobModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+    return instance
+  }
+
+  skip(count: number): JobModel {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  static take(count: number): JobModel {
+    const instance = new JobModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+    return instance
+  }
+
+  take(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
   async pluck<K extends keyof JobModel>(field: K): Promise<JobModel[K][]> {
     if (this.hasSelect) {
       const model = await this.selectFromQuery.execute()

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

@@ -234,6 +234,34 @@ export class PaymentMethodModel {
     return model.map(modelItem => instance.parseResult(new PaymentMethodModel(modelItem)))
   }
 
+  static skip(count: number): PaymentMethodModel {
+    const instance = new PaymentMethodModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+    return instance
+  }
+
+  skip(count: number): PaymentMethodModel {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  static take(count: number): PaymentMethodModel {
+    const instance = new PaymentMethodModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+    return instance
+  }
+
+  take(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
   async pluck<K extends keyof PaymentMethodModel>(field: K): Promise<PaymentMethodModel[K][]> {
     if (this.hasSelect) {
       const model = await this.selectFromQuery.execute()

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

@@ -205,6 +205,34 @@ export class PostModel {
     return model.map(modelItem => instance.parseResult(new PostModel(modelItem)))
   }
 
+  static skip(count: number): PostModel {
+    const instance = new PostModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+    return instance
+  }
+
+  skip(count: number): PostModel {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  static take(count: number): PostModel {
+    const instance = new PostModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+    return instance
+  }
+
+  take(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
   async pluck<K extends keyof PostModel>(field: K): Promise<PostModel[K][]> {
     if (this.hasSelect) {
       const model = await this.selectFromQuery.execute()

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

@@ -211,6 +211,34 @@ export class ProductModel {
     return model.map(modelItem => instance.parseResult(new ProductModel(modelItem)))
   }
 
+  static skip(count: number): ProductModel {
+    const instance = new ProductModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+    return instance
+  }
+
+  skip(count: number): ProductModel {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  static take(count: number): ProductModel {
+    const instance = new ProductModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+    return instance
+  }
+
+  take(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
   async pluck<K extends keyof ProductModel>(field: K): Promise<ProductModel[K][]> {
     if (this.hasSelect) {
       const model = await this.selectFromQuery.execute()

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

@@ -198,6 +198,34 @@ export class ProjectModel {
     return model.map(modelItem => instance.parseResult(new ProjectModel(modelItem)))
   }
 
+  static skip(count: number): ProjectModel {
+    const instance = new ProjectModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.offset(count)
+
+    return instance
+  }
+
+  skip(count: number): ProjectModel {
+    this.selectFromQuery = this.selectFromQuery.offset(count)
+
+    return this
+  }
+
+  static take(count: number): ProjectModel {
+    const instance = new ProjectModel(null)
+
+    instance.selectFromQuery = instance.selectFromQuery.limit(count)
+
+    return instance
+  }
+
+  take(count: number): this {
+    this.selectFromQuery = this.selectFromQuery.limit(count)
+
+    return this
+  }
+
   async pluck<K extends keyof ProjectModel>(field: K): Promise<ProjectModel[K][]> {
     if (this.hasSelect) {
       const model = await this.selectFromQuery.execute()