chore: wip

Author: glennmichael123

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

@@ -904,7 +904,7 @@ export async function generateModelString(
       import { manageCharge, manageCheckout, manageCustomer, manageInvoice, managePaymentMethod, manageSubscription, manageTransaction, managePrice, manageSetupIntent, type Stripe } from '@stacksjs/payments'
       import { sql } from '@stacksjs/database'
       import { DB, BaseOrm } from '@stacksjs/orm'
-      import type { CheckoutLineItem, CheckoutOptions, StripeCustomerOptions } from '@stacksjs/types'
+      import type { CheckoutLineItem, CheckoutOptions, Operator, StripeCustomerOptions } from '@stacksjs/types'
       import { HttpError } from '@stacksjs/error-handling'
       import { dispatch } from '@stacksjs/events'
       import { generateTwoFactorSecret } from '@stacksjs/auth'
@@ -1163,6 +1163,18 @@ export async function generateModelString(
           return instance.applyWhereBetween<V>(column, range)
         }
 
+        static whereRef(column: keyof ${formattedTableName}Table, ...args: string[]): ${modelName}Model {
+          const instance = new ${modelName}Model(undefined)
+
+          return instance.applyWhereRef(column, ...args)
+        }
+
+        static when(condition: boolean, callback: (query: ${modelName}Model) => ${modelName}Model): ${modelName}Model {
+          const instance = new ${modelName}Model(undefined)
+
+          return instance.applyWhen(condition, callback as any)
+        }
+
         static whereLike(column: keyof ${formattedTableName}Table, value: string): ${modelName}Model {
           const instance = new ${modelName}Model(undefined)
 
@@ -1187,6 +1199,18 @@ export async function generateModelString(
           return instance.applyOrderByDesc(column)
         }
 
+        static inRandomOrder(): ${modelName}Model {
+          const instance = new ${modelName}Model(undefined)
+
+          return instance.applyInRandomOrder()
+        }
+
+        static whereColumn(first: keyof ${formattedTableName}Table, operator: Operator, second: keyof ${formattedTableName}Table): ${modelName}Model {
+          const instance = new ${modelName}Model(undefined)
+
+          return instance.applyWhereColumn(first, operator, second)
+        }
+
         static async max(field: keyof ${formattedTableName}Table): Promise<number> {
           const instance = new ${modelName}Model(undefined)
 
@@ -1217,6 +1241,29 @@ export async function generateModelString(
           return instance.applyCount()
         }
         
+        static async get(): Promise<${modelName}Model[]> {
+          const instance = new ${modelName}Model(undefined)
+          
+          const results = await instance.applyGet()
+          
+          return results.map((item: ${modelName}JsonResponse) => new ${modelName}Model(item))
+        }
+        
+        static async pluck<K extends keyof ${modelName}Model>(field: K): Promise<${modelName}Model[K][]> {
+          const instance = new ${modelName}Model(undefined)
+          
+          return await instance.applyPluck(field)
+        }
+        
+        static async chunk(size: number, callback: (models: ${modelName}Model[]) => Promise<void>): Promise<void> {
+          const instance = new ${modelName}Model(undefined)
+          
+          await instance.applyChunk(size, async (models) => {
+            const modelInstances = models.map((item: ${modelName}JsonResponse) => new ${modelName}Model(item))
+            await callback(modelInstances)
+          })
+        }
+        
         static async paginate(options: { limit?: number, offset?: number, page?: number } = { limit: 10, offset: 0, page: 1 }): Promise<{ 
           data: ${modelName}Model[], 
           paging: { 
@@ -1269,6 +1316,27 @@ export async function generateModelString(
           return await instance.applyCreate(new${modelName})
         }
   
+        static async firstOrCreate(search: Partial<${formattedTableName}Table>, values: New${modelName} = {} as New${modelName}): Promise<${modelName}Model> {
+          // First try to find a record matching the search criteria
+          const instance = new ${modelName}Model(undefined)
+          
+          // Apply all search conditions
+          for (const [key, value] of Object.entries(search)) {
+            instance.selectFromQuery = instance.selectFromQuery.where(key, '=', value)
+          }
+          
+          // Try to find the record
+          const existingRecord = await instance.applyFirst()
+          
+          if (existingRecord) {
+            return new ${modelName}Model(existingRecord)
+          }
+          
+          // If no record exists, create a new one with combined search criteria and values
+          const createData = { ...search, ...values } as New${modelName}
+          return await ${modelName}Model.create(createData)
+        }
+  
         async update(new${modelName}: ${modelName}Update): Promise<${modelName}Model | undefined> {
           const filteredValues = Object.fromEntries(
             Object.entries(new${modelName}).filter(([key]) => 

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

@@ -1,4 +1,5 @@
 import type { Generated, Insertable, RawBuilder, Selectable, Updateable } from '@stacksjs/database'
+import type { Operator } from '@stacksjs/types'
 import type { TeamModel } from './Team'
 import type { UserModel } from './User'
 import { sql } from '@stacksjs/database'
@@ -372,6 +373,24 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
     return instance.applyWhereNotIn<V>(column, values)
   }
 
+  static whereBetween<V = number>(column: keyof PersonalAccessTokensTable, range: [V, V]): AccessTokenModel {
+    const instance = new AccessTokenModel(undefined)
+
+    return instance.applyWhereBetween<V>(column, range)
+  }
+
+  static whereRef(column: keyof PersonalAccessTokensTable, ...args: string[]): AccessTokenModel {
+    const instance = new AccessTokenModel(undefined)
+
+    return instance.applyWhereRef(column, ...args)
+  }
+
+  static when(condition: boolean, callback: (query: AccessTokenModel) => AccessTokenModel): AccessTokenModel {
+    const instance = new AccessTokenModel(undefined)
+
+    return instance.applyWhen(condition, callback as any)
+  }
+
   static whereLike(column: keyof PersonalAccessTokensTable, value: string): AccessTokenModel {
     const instance = new AccessTokenModel(undefined)
 
@@ -396,6 +415,18 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
     return instance.applyOrderByDesc(column)
   }
 
+  static inRandomOrder(): AccessTokenModel {
+    const instance = new AccessTokenModel(undefined)
+
+    return instance.applyInRandomOrder()
+  }
+
+  static whereColumn(first: keyof PersonalAccessTokensTable, operator: Operator, second: keyof PersonalAccessTokensTable): AccessTokenModel {
+    const instance = new AccessTokenModel(undefined)
+
+    return instance.applyWhereColumn(first, operator, second)
+  }
+
   static async max(field: keyof PersonalAccessTokensTable): Promise<number> {
     const instance = new AccessTokenModel(undefined)
 
@@ -426,6 +457,29 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
     return instance.applyCount()
   }
 
+  static async get(): Promise<AccessTokenModel[]> {
+    const instance = new AccessTokenModel(undefined)
+
+    const results = await instance.applyGet()
+
+    return results.map((item: AccessTokenJsonResponse) => new AccessTokenModel(item))
+  }
+
+  static async pluck<K extends keyof AccessTokenModel>(field: K): Promise<AccessTokenModel[K][]> {
+    const instance = new AccessTokenModel(undefined)
+
+    return await instance.applyPluck(field)
+  }
+
+  static async chunk(size: number, callback: (models: AccessTokenModel[]) => Promise<void>): Promise<void> {
+    const instance = new AccessTokenModel(undefined)
+
+    await instance.applyChunk(size, async (models) => {
+      const modelInstances = models.map((item: AccessTokenJsonResponse) => new AccessTokenModel(item))
+      await callback(modelInstances)
+    })
+  }
+
   static async paginate(options: { limit?: number, offset?: number, page?: number } = { limit: 10, offset: 0, page: 1 }): Promise<{
     data: AccessTokenModel[]
     paging: {
@@ -474,6 +528,27 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
     return await instance.applyCreate(newAccessToken)
   }
 
+  static async firstOrCreate(search: Partial<PersonalAccessTokensTable>, values: NewAccessToken = {} as NewAccessToken): Promise<AccessTokenModel> {
+    // First try to find a record matching the search criteria
+    const instance = new AccessTokenModel(undefined)
+
+    // Apply all search conditions
+    for (const [key, value] of Object.entries(search)) {
+      instance.selectFromQuery = instance.selectFromQuery.where(key, '=', value)
+    }
+
+    // Try to find the record
+    const existingRecord = await instance.applyFirst()
+
+    if (existingRecord) {
+      return new AccessTokenModel(existingRecord)
+    }
+
+    // If no record exists, create a new one with combined search criteria and values
+    const createData = { ...search, ...values } as NewAccessToken
+    return await AccessTokenModel.create(createData)
+  }
+
   async update(newAccessToken: AccessTokenUpdate): Promise<AccessTokenModel | undefined> {
     const filteredValues = Object.fromEntries(
       Object.entries(newAccessToken).filter(([key]) =>

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

@@ -1,4 +1,5 @@
 import type { Generated, Insertable, RawBuilder, Selectable, Updateable } from '@stacksjs/database'
+import type { Operator } from '@stacksjs/types'
 import type { OrderModel } from './Order'
 import type { ProductModel } from './Product'
 import { randomUUIDv7 } from 'bun'
@@ -414,6 +415,24 @@ export class CouponModel extends BaseOrm<CouponModel, CouponsTable, CouponJsonRe
     return instance.applyWhereNotIn<V>(column, values)
   }
 
+  static whereBetween<V = number>(column: keyof CouponsTable, range: [V, V]): CouponModel {
+    const instance = new CouponModel(undefined)
+
+    return instance.applyWhereBetween<V>(column, range)
+  }
+
+  static whereRef(column: keyof CouponsTable, ...args: string[]): CouponModel {
+    const instance = new CouponModel(undefined)
+
+    return instance.applyWhereRef(column, ...args)
+  }
+
+  static when(condition: boolean, callback: (query: CouponModel) => CouponModel): CouponModel {
+    const instance = new CouponModel(undefined)
+
+    return instance.applyWhen(condition, callback as any)
+  }
+
   static whereLike(column: keyof CouponsTable, value: string): CouponModel {
     const instance = new CouponModel(undefined)
 
@@ -438,6 +457,18 @@ export class CouponModel extends BaseOrm<CouponModel, CouponsTable, CouponJsonRe
     return instance.applyOrderByDesc(column)
   }
 
+  static inRandomOrder(): CouponModel {
+    const instance = new CouponModel(undefined)
+
+    return instance.applyInRandomOrder()
+  }
+
+  static whereColumn(first: keyof CouponsTable, operator: Operator, second: keyof CouponsTable): CouponModel {
+    const instance = new CouponModel(undefined)
+
+    return instance.applyWhereColumn(first, operator, second)
+  }
+
   static async max(field: keyof CouponsTable): Promise<number> {
     const instance = new CouponModel(undefined)
 
@@ -468,6 +499,29 @@ export class CouponModel extends BaseOrm<CouponModel, CouponsTable, CouponJsonRe
     return instance.applyCount()
   }
 
+  static async get(): Promise<CouponModel[]> {
+    const instance = new CouponModel(undefined)
+
+    const results = await instance.applyGet()
+
+    return results.map((item: CouponJsonResponse) => new CouponModel(item))
+  }
+
+  static async pluck<K extends keyof CouponModel>(field: K): Promise<CouponModel[K][]> {
+    const instance = new CouponModel(undefined)
+
+    return await instance.applyPluck(field)
+  }
+
+  static async chunk(size: number, callback: (models: CouponModel[]) => Promise<void>): Promise<void> {
+    const instance = new CouponModel(undefined)
+
+    await instance.applyChunk(size, async (models) => {
+      const modelInstances = models.map((item: CouponJsonResponse) => new CouponModel(item))
+      await callback(modelInstances)
+    })
+  }
+
   static async paginate(options: { limit?: number, offset?: number, page?: number } = { limit: 10, offset: 0, page: 1 }): Promise<{
     data: CouponModel[]
     paging: {
@@ -521,6 +575,27 @@ export class CouponModel extends BaseOrm<CouponModel, CouponsTable, CouponJsonRe
     return await instance.applyCreate(newCoupon)
   }
 
+  static async firstOrCreate(search: Partial<CouponsTable>, values: NewCoupon = {} as NewCoupon): Promise<CouponModel> {
+    // First try to find a record matching the search criteria
+    const instance = new CouponModel(undefined)
+
+    // Apply all search conditions
+    for (const [key, value] of Object.entries(search)) {
+      instance.selectFromQuery = instance.selectFromQuery.where(key, '=', value)
+    }
+
+    // Try to find the record
+    const existingRecord = await instance.applyFirst()
+
+    if (existingRecord) {
+      return new CouponModel(existingRecord)
+    }
+
+    // If no record exists, create a new one with combined search criteria and values
+    const createData = { ...search, ...values } as NewCoupon
+    return await CouponModel.create(createData)
+  }
+
   async update(newCoupon: CouponUpdate): Promise<CouponModel | undefined> {
     const filteredValues = Object.fromEntries(
       Object.entries(newCoupon).filter(([key]) =>