chore: wip

Author: glennmichael123

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

@@ -10,6 +10,7 @@ export class BaseOrm<T, C> {
   protected selectFromQuery: any
   protected updateFromQuery: any
   protected deleteFromQuery: any
+  protected withRelations: string[]
   protected hasSelect: boolean = false
 
   constructor(tableName: string) {
@@ -18,6 +19,8 @@ export class BaseOrm<T, C> {
     this.selectFromQuery = DB.instance.selectFrom(this.tableName)
     this.updateFromQuery = DB.instance.updateTable(this.tableName)
     this.deleteFromQuery = DB.instance.deleteFrom(this.tableName)
+
+    this.withRelations = []
   }
 
   // The protected helper method that does the actual work
@@ -254,6 +257,73 @@ export class BaseOrm<T, C> {
     return this.applyWhereNotIn<V>(column, values)
   }
 
+  async exists(): Promise<boolean> {
+    let model
+
+    if (this.hasSelect) {
+      model = await this.selectFromQuery.executeTakeFirst()
+    }
+    else {
+      model = await this.selectFromQuery.selectAll().executeTakeFirst()
+    }
+
+    return model !== null && model !== undefined
+  }
+
+  with(relations: string[]): this {
+    this.withRelations = relations
+
+    return this
+  }
+
+  async applyLast(): Promise<T | undefined> {
+    let model
+
+    if (this.hasSelect) {
+      model = await this.selectFromQuery.executeTakeFirst()
+    }
+    else {
+      model = await this.selectFromQuery.selectAll().orderBy('id', 'desc').executeTakeFirst()
+    }
+
+    if (model) {
+      this.mapCustomGetters(model)
+      await this.loadRelations(model)
+    }
+
+    return model
+  }
+
+  applyOrderBy(column: keyof C, order: 'asc' | 'desc'): this {
+    this.selectFromQuery = this.selectFromQuery.orderBy(column, order)
+
+    return this
+  }
+
+  orderBy(column: keyof C, order: 'asc' | 'desc'): this {
+    return this.orderBy(column, order)
+  }
+
+  applyGroupBy(column: keyof C): this {
+    this.selectFromQuery = this.selectFromQuery.groupBy(column)
+
+    return this
+  }
+
+  groupBy(column: keyof C): this {
+    return this.applyGroupBy(column)
+  }
+
+  applyHaving<V = string>(column: keyof C, operator: Operator, value: V): this {
+    this.selectFromQuery = this.selectFromQuery.having(column, operator, value)
+
+    return this
+  }
+
+  having<V = string>(column: keyof C, operator: Operator, value: V): this {
+    return this.applyHaving<V>(column, operator, value)
+  }
+
   // Methods to be implemented by child classes
   protected mapCustomGetters(_model: T): void {}
 

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

@@ -948,7 +948,6 @@ export async function generateModelString(
         protected originalAttributes = {} as ${modelName}JsonResponse
         ${privateSoftDeletes}
         protected selectFromQuery: any
-        protected withRelations: string[]
         protected updateFromQuery: any
         protected deleteFromQuery: any
         protected hasSelect: boolean
@@ -1977,12 +1976,6 @@ export async function generateModelString(
           }
         }
   
-        with(relations: string[]): ${modelName}Model {
-          this.withRelations = relations
-            
-          return this
-        }
-  
         static with(relations: string[]): ${modelName}Model {
           const instance = new ${modelName}Model(undefined)
     
@@ -1992,27 +1985,17 @@ export async function generateModelString(
         }
   
         async last(): Promise<${modelName}Model | undefined> {
-          let model: ${modelName}JsonResponse | undefined
-
-          if (this.hasSelect) {
-            model = await this.selectFromQuery.executeTakeFirst()
-          }
-          else {
-            model = await this.selectFromQuery.selectAll().orderBy('id', 'desc').executeTakeFirst()
-          }
-
-          if (model) {
-            this.mapCustomGetters(model)
-            await this.loadRelations(model)
-          }
+          const model = await this.applyLast()
 
           const data = new ${modelName}Model(model)
   
           return data
         }
   
         static async last(): Promise<${modelName}Model | undefined> {
-          const model = await DB.instance.selectFrom('${tableName}').selectAll().orderBy('id', 'desc').executeTakeFirst()
+          const instance = new ${modelName}Model(undefined)
+
+          const model = await instance.applyLast()
   
           if (!model)
             return undefined
@@ -2022,46 +2005,22 @@ export async function generateModelString(
           return data
         }
 
-        orderBy(column: keyof ${formattedTableName}Table, order: 'asc' | 'desc'): ${modelName}Model {
-          this.selectFromQuery = this.selectFromQuery.orderBy(column, order)
-  
-          return this
-        }
-  
         static orderBy(column: keyof ${formattedTableName}Table, order: 'asc' | 'desc'): ${modelName}Model {
-          const instance = new ${modelName}Model(undefined)
-  
-          instance.selectFromQuery = instance.selectFromQuery.orderBy(column, order)
-  
-          return instance
-        }
+          const instance = new UserModel(undefined)
 
-        groupBy(column: keyof ${formattedTableName}Table): ${modelName}Model {
-          this.selectFromQuery = this.selectFromQuery.groupBy(column)
-  
-          return this
+          return instance.applyOrderBy(column, order)
         }
-  
+
         static groupBy(column: keyof ${formattedTableName}Table): ${modelName}Model {
           const instance = new ${modelName}Model(undefined)
-  
-          instance.selectFromQuery = instance.selectFromQuery.groupBy(column)
-  
-          return instance
-        }
 
-        having<V = string>(column: keyof ${formattedTableName}Table, operator: Operator, value: V): ${modelName}Model {
-          this.selectFromQuery = this.selectFromQuery.having(column, operator, value)
-  
-          return this
+          return instance.applyGroupBy(column)
         }
 
         static having<V = string>(column: keyof ${formattedTableName}Table, operator: Operator, value: V): ${modelName}Model {
           const instance = new ${modelName}Model(undefined)
-  
-          instance.selectFromQuery = instance.selectFromQuery.having(column, operator, value)
-  
-          return instance
+
+          return instance.applyHaving(column, operator, value)
         }
 
         inRandomOrder(): ${modelName}Model {

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

@@ -68,7 +68,6 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
   protected originalAttributes = {} as AccessTokenJsonResponse
 
   protected selectFromQuery: any
-  protected withRelations: string[]
   protected updateFromQuery: any
   protected deleteFromQuery: any
   protected hasSelect: boolean
@@ -1266,12 +1265,6 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
     }
   }
 
-  with(relations: string[]): AccessTokenModel {
-    this.withRelations = relations
-
-    return this
-  }
-
   static with(relations: string[]): AccessTokenModel {
     const instance = new AccessTokenModel(undefined)
 
@@ -1281,27 +1274,17 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
   }
 
   async last(): Promise<AccessTokenModel | undefined> {
-    let model: AccessTokenJsonResponse | undefined
-
-    if (this.hasSelect) {
-      model = await this.selectFromQuery.executeTakeFirst()
-    }
-    else {
-      model = await this.selectFromQuery.selectAll().orderBy('id', 'desc').executeTakeFirst()
-    }
-
-    if (model) {
-      this.mapCustomGetters(model)
-      await this.loadRelations(model)
-    }
+    const model = await this.applyLast()
 
     const data = new AccessTokenModel(model)
 
     return data
   }
 
   static async last(): Promise<AccessTokenModel | undefined> {
-    const model = await DB.instance.selectFrom('personal_access_tokens').selectAll().orderBy('id', 'desc').executeTakeFirst()
+    const instance = new AccessTokenModel(undefined)
+
+    const model = await instance.applyLast()
 
     if (!model)
       return undefined
@@ -1311,46 +1294,22 @@ export class AccessTokenModel extends BaseOrm<AccessTokenModel, PersonalAccessTo
     return data
   }
 
-  orderBy(column: keyof PersonalAccessTokensTable, order: 'asc' | 'desc'): AccessTokenModel {
-    this.selectFromQuery = this.selectFromQuery.orderBy(column, order)
-
-    return this
-  }
-
   static orderBy(column: keyof PersonalAccessTokensTable, order: 'asc' | 'desc'): AccessTokenModel {
-    const instance = new AccessTokenModel(undefined)
-
-    instance.selectFromQuery = instance.selectFromQuery.orderBy(column, order)
-
-    return instance
-  }
-
-  groupBy(column: keyof PersonalAccessTokensTable): AccessTokenModel {
-    this.selectFromQuery = this.selectFromQuery.groupBy(column)
+    const instance = new UserModel(undefined)
 
-    return this
+    return instance.applyOrderBy(column, order)
   }
 
   static groupBy(column: keyof PersonalAccessTokensTable): AccessTokenModel {
     const instance = new AccessTokenModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.groupBy(column)
-
-    return instance
-  }
-
-  having<V = string>(column: keyof PersonalAccessTokensTable, operator: Operator, value: V): AccessTokenModel {
-    this.selectFromQuery = this.selectFromQuery.having(column, operator, value)
-
-    return this
+    return instance.applyGroupBy(column)
   }
 
   static having<V = string>(column: keyof PersonalAccessTokensTable, operator: Operator, value: V): AccessTokenModel {
     const instance = new AccessTokenModel(undefined)
 
-    instance.selectFromQuery = instance.selectFromQuery.having(column, operator, value)
-
-    return instance
+    return instance.applyHaving(column, operator, value)
   }
 
   inRandomOrder(): AccessTokenModel {