chore: wip

Author: glennmichael123

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

@@ -1771,31 +1771,28 @@ export async function generateModelString(
         const models = await db.selectFrom('${tableName}').selectAll().execute()
 
         const data = await Promise.all(models.map(async (model: ${modelName}Type) => {
-          ${relationDeclare}
-      
-          ${relationStringMany}
-          ${relationStringBelong}
+          const instance = new ${modelName}Model(model)
+
+          const results = await instance.mapWith(model)
 
-          return new ${modelName}Model(model)
+          return new ${modelName}Model(results)
         }))
 
         return data
       }
 
-
-
       static async findOrFail(id: number): Promise<${modelName}Model> {
         const model = await db.selectFrom('${tableName}').where('id', '=', id).selectAll().executeTakeFirst()
 
+        const instance = new ${modelName}Model(null)
+
         ${instanceSoftDeleteStatements}
 
         if (model === undefined)
           throw new HttpError(404, \`No ${modelName}Model results for \${id}\`)
 
         cache.getOrSet(\`${formattedModelName}:\${id}\`, JSON.stringify(model))
 
-        const instance = new ${modelName}Model(null)
-
         const result = await instance.mapWith(model)
 
         const data = new ${modelName}Model(result as ${modelName}Type)

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

@@ -126,7 +126,11 @@ export class AccessTokenModel {
     const models = await db.selectFrom('personal_access_tokens').selectAll().execute()
 
     const data = await Promise.all(models.map(async (model: AccessTokenType) => {
-      return new AccessTokenModel(model)
+      const instance = new AccessTokenModel(model)
+
+      const results = await instance.mapWith(model)
+
+      return new AccessTokenModel(results)
     }))
 
     return data
@@ -135,13 +139,13 @@ export class AccessTokenModel {
   static async findOrFail(id: number): Promise<AccessTokenModel> {
     const model = await db.selectFrom('personal_access_tokens').where('id', '=', id).selectAll().executeTakeFirst()
 
+    const instance = new AccessTokenModel(null)
+
     if (model === undefined)
       throw new HttpError(404, `No AccessTokenModel results for ${id}`)
 
     cache.getOrSet(`accesstoken:${id}`, JSON.stringify(model))
 
-    const instance = new AccessTokenModel(null)
-
     const result = await instance.mapWith(model)
 
     const data = new AccessTokenModel(result as AccessTokenType)

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

@@ -148,11 +148,11 @@ export class DeploymentModel {
     const models = await db.selectFrom('deployments').selectAll().execute()
 
     const data = await Promise.all(models.map(async (model: DeploymentType) => {
-      const instance = new DeploymentModel(model as DeploymentType)
+      const instance = new DeploymentModel(model)
 
-      model.user = await instance.userBelong()
+      const results = await instance.mapWith(model)
 
-      return new DeploymentModel(model)
+      return new DeploymentModel(results)
     }))
 
     return data
@@ -161,13 +161,13 @@ export class DeploymentModel {
   static async findOrFail(id: number): Promise<DeploymentModel> {
     const model = await db.selectFrom('deployments').where('id', '=', id).selectAll().executeTakeFirst()
 
+    const instance = new DeploymentModel(null)
+
     if (model === undefined)
       throw new HttpError(404, `No DeploymentModel results for ${id}`)
 
     cache.getOrSet(`deployment:${id}`, JSON.stringify(model))
 
-    const instance = new DeploymentModel(null)
-
     const result = await instance.mapWith(model)
 
     const data = new DeploymentModel(result as DeploymentType)

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

@@ -130,7 +130,11 @@ export class ErrorModel {
     const models = await db.selectFrom('errors').selectAll().execute()
 
     const data = await Promise.all(models.map(async (model: ErrorType) => {
-      return new ErrorModel(model)
+      const instance = new ErrorModel(model)
+
+      const results = await instance.mapWith(model)
+
+      return new ErrorModel(results)
     }))
 
     return data
@@ -139,13 +143,13 @@ export class ErrorModel {
   static async findOrFail(id: number): Promise<ErrorModel> {
     const model = await db.selectFrom('errors').where('id', '=', id).selectAll().executeTakeFirst()
 
+    const instance = new ErrorModel(null)
+
     if (model === undefined)
       throw new HttpError(404, `No ErrorModel results for ${id}`)
 
     cache.getOrSet(`error:${id}`, JSON.stringify(model))
 
-    const instance = new ErrorModel(null)
-
     const result = await instance.mapWith(model)
 
     const data = new ErrorModel(result as ErrorType)

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

@@ -156,13 +156,11 @@ export class PaymentMethodModel {
     const models = await db.selectFrom('payment_methods').selectAll().execute()
 
     const data = await Promise.all(models.map(async (model: PaymentMethodType) => {
-      const instance = new PaymentMethodModel(model as PaymentMethodType)
-
-      model.transactions = await instance.transactionsHasMany()
+      const instance = new PaymentMethodModel(model)
 
-      model.user = await instance.userBelong()
+      const results = await instance.mapWith(model)
 
-      return new PaymentMethodModel(model)
+      return new PaymentMethodModel(results)
     }))
 
     return data
@@ -171,13 +169,13 @@ export class PaymentMethodModel {
   static async findOrFail(id: number): Promise<PaymentMethodModel> {
     const model = await db.selectFrom('payment_methods').where('id', '=', id).selectAll().executeTakeFirst()
 
+    const instance = new PaymentMethodModel(null)
+
     if (model === undefined)
       throw new HttpError(404, `No PaymentMethodModel results for ${id}`)
 
     cache.getOrSet(`paymentmethod:${id}`, JSON.stringify(model))
 
-    const instance = new PaymentMethodModel(null)
-
     const result = await instance.mapWith(model)
 
     const data = new PaymentMethodModel(result as PaymentMethodType)

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

@@ -129,11 +129,11 @@ export class PostModel {
     const models = await db.selectFrom('posts').selectAll().execute()
 
     const data = await Promise.all(models.map(async (model: PostType) => {
-      const instance = new PostModel(model as PostType)
+      const instance = new PostModel(model)
 
-      model.user = await instance.userBelong()
+      const results = await instance.mapWith(model)
 
-      return new PostModel(model)
+      return new PostModel(results)
     }))
 
     return data
@@ -142,13 +142,13 @@ export class PostModel {
   static async findOrFail(id: number): Promise<PostModel> {
     const model = await db.selectFrom('posts').where('id', '=', id).selectAll().executeTakeFirst()
 
+    const instance = new PostModel(null)
+
     if (model === undefined)
       throw new HttpError(404, `No PostModel results for ${id}`)
 
     cache.getOrSet(`post:${id}`, JSON.stringify(model))
 
-    const instance = new PostModel(null)
-
     const result = await instance.mapWith(model)
 
     const data = new PostModel(result as PostType)

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

@@ -137,7 +137,11 @@ export class ProductModel {
     const models = await db.selectFrom('products').selectAll().execute()
 
     const data = await Promise.all(models.map(async (model: ProductType) => {
-      return new ProductModel(model)
+      const instance = new ProductModel(model)
+
+      const results = await instance.mapWith(model)
+
+      return new ProductModel(results)
     }))
 
     return data
@@ -146,13 +150,13 @@ export class ProductModel {
   static async findOrFail(id: number): Promise<ProductModel> {
     const model = await db.selectFrom('products').where('id', '=', id).selectAll().executeTakeFirst()
 
+    const instance = new ProductModel(null)
+
     if (model === undefined)
       throw new HttpError(404, `No ProductModel results for ${id}`)
 
     cache.getOrSet(`product:${id}`, JSON.stringify(model))
 
-    const instance = new ProductModel(null)
-
     const result = await instance.mapWith(model)
 
     const data = new ProductModel(result as ProductType)

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

@@ -124,7 +124,11 @@ export class ProjectModel {
     const models = await db.selectFrom('projects').selectAll().execute()
 
     const data = await Promise.all(models.map(async (model: ProjectType) => {
-      return new ProjectModel(model)
+      const instance = new ProjectModel(model)
+
+      const results = await instance.mapWith(model)
+
+      return new ProjectModel(results)
     }))
 
     return data
@@ -133,13 +137,13 @@ export class ProjectModel {
   static async findOrFail(id: number): Promise<ProjectModel> {
     const model = await db.selectFrom('projects').where('id', '=', id).selectAll().executeTakeFirst()
 
+    const instance = new ProjectModel(null)
+
     if (model === undefined)
       throw new HttpError(404, `No ProjectModel results for ${id}`)
 
     cache.getOrSet(`project:${id}`, JSON.stringify(model))
 
-    const instance = new ProjectModel(null)
-
     const result = await instance.mapWith(model)
 
     const data = new ProjectModel(result as ProjectType)

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

@@ -115,7 +115,11 @@ export class ReleaseModel {
     const models = await db.selectFrom('releases').selectAll().execute()
 
     const data = await Promise.all(models.map(async (model: ReleaseType) => {
-      return new ReleaseModel(model)
+      const instance = new ReleaseModel(model)
+
+      const results = await instance.mapWith(model)
+
+      return new ReleaseModel(results)
     }))
 
     return data
@@ -124,13 +128,13 @@ export class ReleaseModel {
   static async findOrFail(id: number): Promise<ReleaseModel> {
     const model = await db.selectFrom('releases').where('id', '=', id).selectAll().executeTakeFirst()
 
+    const instance = new ReleaseModel(null)
+
     if (model === undefined)
       throw new HttpError(404, `No ReleaseModel results for ${id}`)
 
     cache.getOrSet(`release:${id}`, JSON.stringify(model))
 
-    const instance = new ReleaseModel(null)
-
     const result = await instance.mapWith(model)
 
     const data = new ReleaseModel(result as ReleaseType)

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

@@ -115,7 +115,11 @@ export class SubscriberModel {
     const models = await db.selectFrom('subscribers').selectAll().execute()
 
     const data = await Promise.all(models.map(async (model: SubscriberType) => {
-      return new SubscriberModel(model)
+      const instance = new SubscriberModel(model)
+
+      const results = await instance.mapWith(model)
+
+      return new SubscriberModel(results)
     }))
 
     return data
@@ -124,13 +128,13 @@ export class SubscriberModel {
   static async findOrFail(id: number): Promise<SubscriberModel> {
     const model = await db.selectFrom('subscribers').where('id', '=', id).selectAll().executeTakeFirst()
 
+    const instance = new SubscriberModel(null)
+
     if (model === undefined)
       throw new HttpError(404, `No SubscriberModel results for ${id}`)
 
     cache.getOrSet(`subscriber:${id}`, JSON.stringify(model))
 
-    const instance = new SubscriberModel(null)
-
     const result = await instance.mapWith(model)
 
     const data = new SubscriberModel(result as SubscriberType)