chore: wip

Author: glennmichael123

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

@@ -1771,22 +1771,22 @@ export async function generateModelString(
 
 
       static async findOrFail(id: number): Promise<${modelName}Model> {
-        let query = db.selectFrom('${tableName}').where('id', '=', id)
-
-        const instance = new ${modelName}Model(null)
+        const model = await db.selectFrom('${tableName}').where('id', '=', id).selectAll().executeTakeFirst()
 
         ${instanceSoftDeleteStatements}
 
-        query = query.selectAll()
-
-        const model = await query.executeTakeFirst()
-
         if (model === undefined)
           throw new HttpError(404, \`No ${modelName}Model results for \${id}\`)
 
         cache.getOrSet(\`${formattedModelName}:\${id}\`, JSON.stringify(model))
 
-        return instance.parseResult(new ${modelName}Model(model))
+        ${relationDeclare}
+        ${relationStringMany}
+        ${relationStringBelong}
+
+        const data = new ${modelName}Model(model as ${modelName}Type)
+
+        return data
       }
 
       static async findMany(ids: number[]): Promise<${modelName}Model[]> {

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

@@ -123,20 +123,16 @@ export class AccessTokenModel {
   }
 
   static async findOrFail(id: number): Promise<AccessTokenModel> {
-    let query = db.selectFrom('personal_access_tokens').where('id', '=', id)
-
-    const instance = new AccessTokenModel(null)
-
-    query = query.selectAll()
-
-    const model = await query.executeTakeFirst()
+    const model = await db.selectFrom('personal_access_tokens').where('id', '=', id).selectAll().executeTakeFirst()
 
     if (model === undefined)
       throw new HttpError(404, `No AccessTokenModel results for ${id}`)
 
     cache.getOrSet(`accesstoken:${id}`, JSON.stringify(model))
 
-    return instance.parseResult(new AccessTokenModel(model))
+    const data = new AccessTokenModel(model as AccessTokenType)
+
+    return data
   }
 
   static async findMany(ids: number[]): Promise<AccessTokenModel[]> {

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

@@ -149,20 +149,20 @@ export class DeploymentModel {
   }
 
   static async findOrFail(id: number): Promise<DeploymentModel> {
-    let query = db.selectFrom('deployments').where('id', '=', id)
-
-    const instance = new DeploymentModel(null)
-
-    query = query.selectAll()
-
-    const model = await query.executeTakeFirst()
+    const model = await db.selectFrom('deployments').where('id', '=', id).selectAll().executeTakeFirst()
 
     if (model === undefined)
       throw new HttpError(404, `No DeploymentModel results for ${id}`)
 
     cache.getOrSet(`deployment:${id}`, JSON.stringify(model))
 
-    return instance.parseResult(new DeploymentModel(model))
+    const instance = new DeploymentModel(model as DeploymentType)
+
+    model.user = await instance.userBelong()
+
+    const data = new DeploymentModel(model as DeploymentType)
+
+    return data
   }
 
   static async findMany(ids: number[]): Promise<DeploymentModel[]> {

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

@@ -127,20 +127,16 @@ export class ErrorModel {
   }
 
   static async findOrFail(id: number): Promise<ErrorModel> {
-    let query = db.selectFrom('errors').where('id', '=', id)
-
-    const instance = new ErrorModel(null)
-
-    query = query.selectAll()
-
-    const model = await query.executeTakeFirst()
+    const model = await db.selectFrom('errors').where('id', '=', id).selectAll().executeTakeFirst()
 
     if (model === undefined)
       throw new HttpError(404, `No ErrorModel results for ${id}`)
 
     cache.getOrSet(`error:${id}`, JSON.stringify(model))
 
-    return instance.parseResult(new ErrorModel(model))
+    const data = new ErrorModel(model as ErrorType)
+
+    return data
   }
 
   static async findMany(ids: number[]): Promise<ErrorModel[]> {

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

@@ -159,20 +159,22 @@ export class PaymentMethodModel {
   }
 
   static async findOrFail(id: number): Promise<PaymentMethodModel> {
-    let query = db.selectFrom('payment_methods').where('id', '=', id)
-
-    const instance = new PaymentMethodModel(null)
-
-    query = query.selectAll()
-
-    const model = await query.executeTakeFirst()
+    const model = await db.selectFrom('payment_methods').where('id', '=', id).selectAll().executeTakeFirst()
 
     if (model === undefined)
       throw new HttpError(404, `No PaymentMethodModel results for ${id}`)
 
     cache.getOrSet(`paymentmethod:${id}`, JSON.stringify(model))
 
-    return instance.parseResult(new PaymentMethodModel(model))
+    const instance = new PaymentMethodModel(model as PaymentMethodType)
+
+    model.transactions = await instance.transactionsHasMany()
+
+    model.user = await instance.userBelong()
+
+    const data = new PaymentMethodModel(model as PaymentMethodType)
+
+    return data
   }
 
   static async findMany(ids: number[]): Promise<PaymentMethodModel[]> {

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

@@ -130,20 +130,20 @@ export class PostModel {
   }
 
   static async findOrFail(id: number): Promise<PostModel> {
-    let query = db.selectFrom('posts').where('id', '=', id)
-
-    const instance = new PostModel(null)
-
-    query = query.selectAll()
-
-    const model = await query.executeTakeFirst()
+    const model = await db.selectFrom('posts').where('id', '=', id).selectAll().executeTakeFirst()
 
     if (model === undefined)
       throw new HttpError(404, `No PostModel results for ${id}`)
 
     cache.getOrSet(`post:${id}`, JSON.stringify(model))
 
-    return instance.parseResult(new PostModel(model))
+    const instance = new PostModel(model as PostType)
+
+    model.user = await instance.userBelong()
+
+    const data = new PostModel(model as PostType)
+
+    return data
   }
 
   static async findMany(ids: number[]): Promise<PostModel[]> {

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

@@ -134,20 +134,16 @@ export class ProductModel {
   }
 
   static async findOrFail(id: number): Promise<ProductModel> {
-    let query = db.selectFrom('products').where('id', '=', id)
-
-    const instance = new ProductModel(null)
-
-    query = query.selectAll()
-
-    const model = await query.executeTakeFirst()
+    const model = await db.selectFrom('products').where('id', '=', id).selectAll().executeTakeFirst()
 
     if (model === undefined)
       throw new HttpError(404, `No ProductModel results for ${id}`)
 
     cache.getOrSet(`product:${id}`, JSON.stringify(model))
 
-    return instance.parseResult(new ProductModel(model))
+    const data = new ProductModel(model as ProductType)
+
+    return data
   }
 
   static async findMany(ids: number[]): Promise<ProductModel[]> {

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

@@ -121,20 +121,16 @@ export class ProjectModel {
   }
 
   static async findOrFail(id: number): Promise<ProjectModel> {
-    let query = db.selectFrom('projects').where('id', '=', id)
-
-    const instance = new ProjectModel(null)
-
-    query = query.selectAll()
-
-    const model = await query.executeTakeFirst()
+    const model = await db.selectFrom('projects').where('id', '=', id).selectAll().executeTakeFirst()
 
     if (model === undefined)
       throw new HttpError(404, `No ProjectModel results for ${id}`)
 
     cache.getOrSet(`project:${id}`, JSON.stringify(model))
 
-    return instance.parseResult(new ProjectModel(model))
+    const data = new ProjectModel(model as ProjectType)
+
+    return data
   }
 
   static async findMany(ids: number[]): Promise<ProjectModel[]> {

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

@@ -112,20 +112,16 @@ export class ReleaseModel {
   }
 
   static async findOrFail(id: number): Promise<ReleaseModel> {
-    let query = db.selectFrom('releases').where('id', '=', id)
-
-    const instance = new ReleaseModel(null)
-
-    query = query.selectAll()
-
-    const model = await query.executeTakeFirst()
+    const model = await db.selectFrom('releases').where('id', '=', id).selectAll().executeTakeFirst()
 
     if (model === undefined)
       throw new HttpError(404, `No ReleaseModel results for ${id}`)
 
     cache.getOrSet(`release:${id}`, JSON.stringify(model))
 
-    return instance.parseResult(new ReleaseModel(model))
+    const data = new ReleaseModel(model as ReleaseType)
+
+    return data
   }
 
   static async findMany(ids: number[]): Promise<ReleaseModel[]> {

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

@@ -112,20 +112,16 @@ export class SubscriberModel {
   }
 
   static async findOrFail(id: number): Promise<SubscriberModel> {
-    let query = db.selectFrom('subscribers').where('id', '=', id)
-
-    const instance = new SubscriberModel(null)
-
-    query = query.selectAll()
-
-    const model = await query.executeTakeFirst()
+    const model = await db.selectFrom('subscribers').where('id', '=', id).selectAll().executeTakeFirst()
 
     if (model === undefined)
       throw new HttpError(404, `No SubscriberModel results for ${id}`)
 
     cache.getOrSet(`subscriber:${id}`, JSON.stringify(model))
 
-    return instance.parseResult(new SubscriberModel(model))
+    const data = new SubscriberModel(model as SubscriberType)
+
+    return data
   }
 
   static async findMany(ids: number[]): Promise<SubscriberModel[]> {