chore: wip

Author: glennmichael123

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

@@ -552,6 +552,22 @@ export class BaseOrm<T, C, J> {
     return this.applyJoin(table, firstCol, secondCol)
   }
 
+  async applyUpdate<U>(values: U): Promise<T | undefined> {
+    if (!values || Object.keys(values).length === 0)
+      return undefined
+
+    await this.updateFromQuery
+      .set(values as any)
+      .executeTakeFirst()
+
+    // If we have an ID in the current instance, try to find the updated model
+    if ((this as any).id) {
+      return await this.applyFind((this as any).id)
+    }
+
+    return undefined
+  }
+
   // Methods to be implemented by child classes
   protected mapCustomGetters(_model: T): void {}
 

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

@@ -1673,6 +1673,50 @@ export async function generateModelString(
           return await instance.applyCreate(new${modelName})
         }
   
+        async update(new${modelName}: ${modelName}Update): Promise<${modelName}Model | undefined> {
+          const filteredValues = Object.fromEntries(
+            Object.entries(new${modelName}).filter(([key]) => 
+              !this.guarded.includes(key) && this.fillable.includes(key)
+            ),
+          ) as ${modelName}Update
+
+          await this.mapCustomSetters(filteredValues)
+
+          await DB.instance.updateTable('${tableName}')
+            .set(filteredValues)
+            .where('id', '=', this.id)
+            .executeTakeFirst()
+
+          if (this.id) {
+            const model = await this.find(this.id)
+
+            ${mittUpdateStatement}
+    
+            return model
+          }
+
+          this.hasSaved = true
+
+          return undefined
+        }
+
+        async forceUpdate(new${modelName}: ${modelName}Update): Promise<${modelName}Model | undefined> {
+          await DB.instance.updateTable('${tableName}')
+            .set(new${modelName})
+            .where('id', '=', this.id)
+            .executeTakeFirst()
+
+          if (this.id) {
+            const model = await this.find(this.id)
+
+            ${mittUpdateStatement}
+    
+            return model
+          }
+
+          return undefined
+        }
+  
         static async createMany(new${modelName}: New${modelName}[]): Promise<void> {
           const instance = new ${modelName}Model(undefined)
 
@@ -1709,13 +1753,27 @@ export async function generateModelString(
         async delete(): Promise<${formattedTableName}Table> {
           if (this.id === undefined)
             this.deleteFromQuery.execute()
-            ${mittDeleteFindStatement}
-            ${mittDeleteStatement}
-            ${thisSoftDeleteStatementsUpdateFrom}
+          ${mittDeleteFindStatement}
+          ${instanceSoftDeleteStatements}
+          ${mittDeleteStatement}
+
+          await DB.instance.deleteFrom('${tableName}')
+            .where('id', '=', this.id)
+            .execute()
+        }
+
+        static async remove(id: number): Promise<any> {
+          ${removeInstanceStatment}
   
-            return await DB.instance.deleteFrom('${tableName}')
-              .where('id', '=', this.id)
-              .execute()
+          ${mittDeleteStaticFindStatement}
+  
+          ${instanceSoftDeleteStatementsUpdateFrom}
+  
+          ${mittDeleteStatement}
+        
+          return await DB.instance.deleteFrom('${tableName}')
+            .where('id', '=', id)
+            .execute()
         }
   
         ${whereStatements}

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

@@ -896,6 +896,46 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
     return await instance.applyCreate(newAccessToken)
   }
 
+  async update(newAccessToken: AccessTokenUpdate): Promise<AccessTokenModel | undefined> {
+    const filteredValues = Object.fromEntries(
+      Object.entries(newAccessToken).filter(([key]) =>
+        !this.guarded.includes(key) && this.fillable.includes(key),
+      ),
+    ) as AccessTokenUpdate
+
+    await this.mapCustomSetters(filteredValues)
+
+    await DB.instance.updateTable('personal_access_tokens')
+      .set(filteredValues)
+      .where('id', '=', this.id)
+      .executeTakeFirst()
+
+    if (this.id) {
+      const model = await this.find(this.id)
+
+      return model
+    }
+
+    this.hasSaved = true
+
+    return undefined
+  }
+
+  async forceUpdate(newAccessToken: AccessTokenUpdate): Promise<AccessTokenModel | undefined> {
+    await DB.instance.updateTable('personal_access_tokens')
+      .set(newAccessToken)
+      .where('id', '=', this.id)
+      .executeTakeFirst()
+
+    if (this.id) {
+      const model = await this.find(this.id)
+
+      return model
+    }
+
+    return undefined
+  }
+
   static async createMany(newAccessToken: NewAccessToken[]): Promise<void> {
     const instance = new AccessTokenModel(undefined)
 
@@ -929,11 +969,17 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
     if (this.id === undefined)
       this.deleteFromQuery.execute()
 
-    return await DB.instance.deleteFrom('personal_access_tokens')
+    await DB.instance.deleteFrom('personal_access_tokens')
       .where('id', '=', this.id)
       .execute()
   }
 
+  static async remove(id: number): Promise<any> {
+    return await DB.instance.deleteFrom('personal_access_tokens')
+      .where('id', '=', id)
+      .execute()
+  }
+
   static whereName(value: string): AccessTokenModel {
     const instance = new AccessTokenModel(undefined)
 

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

@@ -941,6 +941,52 @@ export class CouponModel extends BaseOrm<CouponModel, CouponsTable, CouponJsonRe
     return await instance.applyCreate(newCoupon)
   }
 
+  async update(newCoupon: CouponUpdate): Promise<CouponModel | undefined> {
+    const filteredValues = Object.fromEntries(
+      Object.entries(newCoupon).filter(([key]) =>
+        !this.guarded.includes(key) && this.fillable.includes(key),
+      ),
+    ) as CouponUpdate
+
+    await this.mapCustomSetters(filteredValues)
+
+    await DB.instance.updateTable('coupons')
+      .set(filteredValues)
+      .where('id', '=', this.id)
+      .executeTakeFirst()
+
+    if (this.id) {
+      const model = await this.find(this.id)
+
+      if (model)
+        dispatch('coupon:updated', model)
+
+      return model
+    }
+
+    this.hasSaved = true
+
+    return undefined
+  }
+
+  async forceUpdate(newCoupon: CouponUpdate): Promise<CouponModel | undefined> {
+    await DB.instance.updateTable('coupons')
+      .set(newCoupon)
+      .where('id', '=', this.id)
+      .executeTakeFirst()
+
+    if (this.id) {
+      const model = await this.find(this.id)
+
+      if (model)
+        dispatch('coupon:updated', model)
+
+      return model
+    }
+
+    return undefined
+  }
+
   static async createMany(newCoupon: NewCoupon[]): Promise<void> {
     const instance = new CouponModel(undefined)
 
@@ -979,14 +1025,28 @@ export class CouponModel extends BaseOrm<CouponModel, CouponsTable, CouponJsonRe
     if (this.id === undefined)
       this.deleteFromQuery.execute()
     const model = await this.find(Number(this.id))
+
     if (model)
       dispatch('coupon:deleted', model)
 
-    return await DB.instance.deleteFrom('coupons')
+    await DB.instance.deleteFrom('coupons')
       .where('id', '=', this.id)
       .execute()
   }
 
+  static async remove(id: number): Promise<any> {
+    const instance = new CouponModel(undefined)
+
+    const model = await instance.find(Number(id))
+
+    if (model)
+      dispatch('coupon:deleted', model)
+
+    return await DB.instance.deleteFrom('coupons')
+      .where('id', '=', id)
+      .execute()
+  }
+
   static whereCode(value: string): CouponModel {
     const instance = new CouponModel(undefined)
 

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

@@ -886,6 +886,52 @@ export class CustomerModel extends BaseOrm<CustomerModel, CustomersTable, Custom
     return await instance.applyCreate(newCustomer)
   }
 
+  async update(newCustomer: CustomerUpdate): Promise<CustomerModel | undefined> {
+    const filteredValues = Object.fromEntries(
+      Object.entries(newCustomer).filter(([key]) =>
+        !this.guarded.includes(key) && this.fillable.includes(key),
+      ),
+    ) as CustomerUpdate
+
+    await this.mapCustomSetters(filteredValues)
+
+    await DB.instance.updateTable('customers')
+      .set(filteredValues)
+      .where('id', '=', this.id)
+      .executeTakeFirst()
+
+    if (this.id) {
+      const model = await this.find(this.id)
+
+      if (model)
+        dispatch('customer:updated', model)
+
+      return model
+    }
+
+    this.hasSaved = true
+
+    return undefined
+  }
+
+  async forceUpdate(newCustomer: CustomerUpdate): Promise<CustomerModel | undefined> {
+    await DB.instance.updateTable('customers')
+      .set(newCustomer)
+      .where('id', '=', this.id)
+      .executeTakeFirst()
+
+    if (this.id) {
+      const model = await this.find(this.id)
+
+      if (model)
+        dispatch('customer:updated', model)
+
+      return model
+    }
+
+    return undefined
+  }
+
   static async createMany(newCustomer: NewCustomer[]): Promise<void> {
     const instance = new CustomerModel(undefined)
 
@@ -924,14 +970,28 @@ export class CustomerModel extends BaseOrm<CustomerModel, CustomersTable, Custom
     if (this.id === undefined)
       this.deleteFromQuery.execute()
     const model = await this.find(Number(this.id))
+
     if (model)
       dispatch('customer:deleted', model)
 
-    return await DB.instance.deleteFrom('customers')
+    await DB.instance.deleteFrom('customers')
       .where('id', '=', this.id)
       .execute()
   }
 
+  static async remove(id: number): Promise<any> {
+    const instance = new CustomerModel(undefined)
+
+    const model = await instance.find(Number(id))
+
+    if (model)
+      dispatch('customer:deleted', model)
+
+    return await DB.instance.deleteFrom('customers')
+      .where('id', '=', id)
+      .execute()
+  }
+
   static whereName(value: string): CustomerModel {
     const instance = new CustomerModel(undefined)