chore: wip

Author: glennmichael123

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

@@ -1658,6 +1658,24 @@ export async function generateModelString(
         whereBetween(column: keyof ${modelName}Type, range: [any, any]): ${modelName}Model {
           return ${modelName}Model.whereBetween(column, range)
         }
+
+        whereLike(column: keyof ${modelName}Type, value: string): ${modelName}Model {
+          return ${modelName}Model.whereLike(column, value)
+        }
+          
+        static whereLike(column: keyof ${modelName}Type, value: string): ${modelName}Model {
+          const instance = new ${modelName}Model(null)
+  
+          const query = sql\` \${sql.raw(column as string)} between \${range[0]} and \${range[1]} \`
+  
+          instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+  
+          instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+  
+          instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+  
+          return instance
+        }
   
         static whereBetween(column: keyof ${modelName}Type, range: [any, any]): ${modelName}Model {
           if (range.length !== 2) {

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

@@ -902,6 +902,24 @@ export class AccessTokenModel {
     return AccessTokenModel.whereBetween(column, range)
   }
 
+  whereLike(column: keyof AccessTokenType, value: string): AccessTokenModel {
+    return AccessTokenModel.whereLike(column, value)
+  }
+
+  static whereLike(column: keyof AccessTokenType, value: string): AccessTokenModel {
+    const instance = new AccessTokenModel(null)
+
+    const query = sql` ${sql.raw(column as string)} between ${range[0]} and ${range[1]} `
+
+    instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+
+    instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+
+    instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+
+    return instance
+  }
+
   static whereBetween(column: keyof AccessTokenType, range: [any, any]): AccessTokenModel {
     if (range.length !== 2) {
       throw new HttpError(500, 'Range must have exactly two values: [min, max]')

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

@@ -956,6 +956,24 @@ export class ActivityModel {
     return ActivityModel.whereBetween(column, range)
   }
 
+  whereLike(column: keyof ActivityType, value: string): ActivityModel {
+    return ActivityModel.whereLike(column, value)
+  }
+
+  static whereLike(column: keyof ActivityType, value: string): ActivityModel {
+    const instance = new ActivityModel(null)
+
+    const query = sql` ${sql.raw(column as string)} between ${range[0]} and ${range[1]} `
+
+    instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+
+    instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+
+    instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+
+    return instance
+  }
+
   static whereBetween(column: keyof ActivityType, range: [any, any]): ActivityModel {
     if (range.length !== 2) {
       throw new HttpError(500, 'Range must have exactly two values: [min, max]')

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

@@ -967,6 +967,24 @@ export class DeploymentModel {
     return DeploymentModel.whereBetween(column, range)
   }
 
+  whereLike(column: keyof DeploymentType, value: string): DeploymentModel {
+    return DeploymentModel.whereLike(column, value)
+  }
+
+  static whereLike(column: keyof DeploymentType, value: string): DeploymentModel {
+    const instance = new DeploymentModel(null)
+
+    const query = sql` ${sql.raw(column as string)} between ${range[0]} and ${range[1]} `
+
+    instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+
+    instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+
+    instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+
+    return instance
+  }
+
   static whereBetween(column: keyof DeploymentType, range: [any, any]): DeploymentModel {
     if (range.length !== 2) {
       throw new HttpError(500, 'Range must have exactly two values: [min, max]')

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

@@ -902,6 +902,24 @@ export class ErrorModel {
     return ErrorModel.whereBetween(column, range)
   }
 
+  whereLike(column: keyof ErrorType, value: string): ErrorModel {
+    return ErrorModel.whereLike(column, value)
+  }
+
+  static whereLike(column: keyof ErrorType, value: string): ErrorModel {
+    const instance = new ErrorModel(null)
+
+    const query = sql` ${sql.raw(column as string)} between ${range[0]} and ${range[1]} `
+
+    instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+
+    instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+
+    instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+
+    return instance
+  }
+
   static whereBetween(column: keyof ErrorType, range: [any, any]): ErrorModel {
     if (range.length !== 2) {
       throw new HttpError(500, 'Range must have exactly two values: [min, max]')

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

@@ -902,6 +902,24 @@ export class FailedJobModel {
     return FailedJobModel.whereBetween(column, range)
   }
 
+  whereLike(column: keyof FailedJobType, value: string): FailedJobModel {
+    return FailedJobModel.whereLike(column, value)
+  }
+
+  static whereLike(column: keyof FailedJobType, value: string): FailedJobModel {
+    const instance = new FailedJobModel(null)
+
+    const query = sql` ${sql.raw(column as string)} between ${range[0]} and ${range[1]} `
+
+    instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+
+    instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+
+    instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+
+    return instance
+  }
+
   static whereBetween(column: keyof FailedJobType, range: [any, any]): FailedJobModel {
     if (range.length !== 2) {
       throw new HttpError(500, 'Range must have exactly two values: [min, max]')

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

@@ -902,6 +902,24 @@ export class JobModel {
     return JobModel.whereBetween(column, range)
   }
 
+  whereLike(column: keyof JobType, value: string): JobModel {
+    return JobModel.whereLike(column, value)
+  }
+
+  static whereLike(column: keyof JobType, value: string): JobModel {
+    const instance = new JobModel(null)
+
+    const query = sql` ${sql.raw(column as string)} between ${range[0]} and ${range[1]} `
+
+    instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+
+    instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+
+    instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+
+    return instance
+  }
+
   static whereBetween(column: keyof JobType, range: [any, any]): JobModel {
     if (range.length !== 2) {
       throw new HttpError(500, 'Range must have exactly two values: [min, max]')

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

@@ -980,6 +980,24 @@ export class PaymentMethodModel {
     return PaymentMethodModel.whereBetween(column, range)
   }
 
+  whereLike(column: keyof PaymentMethodType, value: string): PaymentMethodModel {
+    return PaymentMethodModel.whereLike(column, value)
+  }
+
+  static whereLike(column: keyof PaymentMethodType, value: string): PaymentMethodModel {
+    const instance = new PaymentMethodModel(null)
+
+    const query = sql` ${sql.raw(column as string)} between ${range[0]} and ${range[1]} `
+
+    instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+
+    instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+
+    instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+
+    return instance
+  }
+
   static whereBetween(column: keyof PaymentMethodType, range: [any, any]): PaymentMethodModel {
     if (range.length !== 2) {
       throw new HttpError(500, 'Range must have exactly two values: [min, max]')

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

@@ -868,6 +868,24 @@ export class PostModel {
     return PostModel.whereBetween(column, range)
   }
 
+  whereLike(column: keyof PostType, value: string): PostModel {
+    return PostModel.whereLike(column, value)
+  }
+
+  static whereLike(column: keyof PostType, value: string): PostModel {
+    const instance = new PostModel(null)
+
+    const query = sql` ${sql.raw(column as string)} between ${range[0]} and ${range[1]} `
+
+    instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+
+    instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+
+    instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+
+    return instance
+  }
+
   static whereBetween(column: keyof PostType, range: [any, any]): PostModel {
     if (range.length !== 2) {
       throw new HttpError(500, 'Range must have exactly two values: [min, max]')

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

@@ -950,6 +950,24 @@ export class ProductModel {
     return ProductModel.whereBetween(column, range)
   }
 
+  whereLike(column: keyof ProductType, value: string): ProductModel {
+    return ProductModel.whereLike(column, value)
+  }
+
+  static whereLike(column: keyof ProductType, value: string): ProductModel {
+    const instance = new ProductModel(null)
+
+    const query = sql` ${sql.raw(column as string)} between ${range[0]} and ${range[1]} `
+
+    instance.selectFromQuery = instance.selectFromQuery.where(column, 'LIKE', values)
+
+    instance.updateFromQuery = instance.updateFromQuery.where(column, 'LIKE', values)
+
+    instance.deleteFromQuery = instance.deleteFromQuery.where(column, 'LIKE', values)
+
+    return instance
+  }
+
   static whereBetween(column: keyof ProductType, range: [any, any]): ProductModel {
     if (range.length !== 2) {
       throw new HttpError(500, 'Range must have exactly two values: [min, max]')