chore: wip

glennmichael123 · glennmichael123 · commit 851275b7809b · 2025-03-05T22:27:25.000+08:00
diff --git a/storage/framework/core/orm/src/generate.ts b/storage/framework/core/orm/src/generate.ts
@@ -1328,7 +1328,14 @@ export async function generateModelString(
         }
 
         async pluck<K extends keyof ${modelName}Model>(field: K): Promise<${modelName}Model[K][]> {
-          return ${modelName}Model.pluck(field)
+          if (this.hasSelect) {
+            const model = await this.selectFromQuery.execute()
+            return model.map((modelItem: ${modelName}Model) => modelItem[field])
+          }
+
+          const model = await this.selectFromQuery.selectAll().execute()
+
+          return model.map((modelItem: ${modelName}Model) => modelItem[field])
         }
 
         static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/AccessToken.ts b/storage/framework/orm/src/models/AccessToken.ts
@@ -545,7 +545,14 @@ export class AccessTokenModel {
   }
 
   async pluck<K extends keyof AccessTokenModel>(field: K): Promise<AccessTokenModel[K][]> {
-    return AccessTokenModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: AccessTokenModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: AccessTokenModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Coupon.ts b/storage/framework/orm/src/models/Coupon.ts
@@ -585,7 +585,14 @@ export class CouponModel {
   }
 
   async pluck<K extends keyof CouponModel>(field: K): Promise<CouponModel[K][]> {
-    return CouponModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: CouponModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: CouponModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Customer.ts b/storage/framework/orm/src/models/Customer.ts
@@ -530,7 +530,14 @@ export class CustomerModel {
   }
 
   async pluck<K extends keyof CustomerModel>(field: K): Promise<CustomerModel[K][]> {
-    return CustomerModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: CustomerModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: CustomerModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Deployment.ts b/storage/framework/orm/src/models/Deployment.ts
@@ -514,7 +514,14 @@ export class DeploymentModel {
   }
 
   async pluck<K extends keyof DeploymentModel>(field: K): Promise<DeploymentModel[K][]> {
-    return DeploymentModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: DeploymentModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: DeploymentModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Error.ts b/storage/framework/orm/src/models/Error.ts
@@ -473,7 +473,14 @@ export class ErrorModel {
   }
 
   async pluck<K extends keyof ErrorModel>(field: K): Promise<ErrorModel[K][]> {
-    return ErrorModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: ErrorModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: ErrorModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/FailedJob.ts b/storage/framework/orm/src/models/FailedJob.ts
@@ -473,7 +473,14 @@ export class FailedJobModel {
   }
 
   async pluck<K extends keyof FailedJobModel>(field: K): Promise<FailedJobModel[K][]> {
-    return FailedJobModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: FailedJobModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: FailedJobModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/GiftCard.ts b/storage/framework/orm/src/models/GiftCard.ts
@@ -594,7 +594,14 @@ export class GiftCardModel {
   }
 
   async pluck<K extends keyof GiftCardModel>(field: K): Promise<GiftCardModel[K][]> {
-    return GiftCardModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: GiftCardModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: GiftCardModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Job.ts b/storage/framework/orm/src/models/Job.ts
@@ -473,7 +473,14 @@ export class JobModel {
   }
 
   async pluck<K extends keyof JobModel>(field: K): Promise<JobModel[K][]> {
-    return JobModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: JobModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: JobModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/LoyaltyPoint.ts b/storage/framework/orm/src/models/LoyaltyPoint.ts
@@ -502,7 +502,14 @@ export class LoyaltyPointModel {
   }
 
   async pluck<K extends keyof LoyaltyPointModel>(field: K): Promise<LoyaltyPointModel[K][]> {
-    return LoyaltyPointModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: LoyaltyPointModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: LoyaltyPointModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/LoyaltyReward.ts b/storage/framework/orm/src/models/LoyaltyReward.ts
@@ -533,7 +533,14 @@ export class LoyaltyRewardModel {
   }
 
   async pluck<K extends keyof LoyaltyRewardModel>(field: K): Promise<LoyaltyRewardModel[K][]> {
-    return LoyaltyRewardModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: LoyaltyRewardModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: LoyaltyRewardModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Order.ts b/storage/framework/orm/src/models/Order.ts
@@ -1,6 +1,7 @@
 import type { Insertable, RawBuilder, Selectable, Updateable } from '@stacksjs/database'
 import type { Operator } from '@stacksjs/orm'
 import type { CouponModel } from './Coupon'
+import type { OrderModel } from './Order'
 import type { UserModel } from './User'
 import { randomUUIDv7 } from 'bun'
 import { cache } from '@stacksjs/cache'
@@ -13,6 +14,7 @@ import { DB, SubqueryBuilder } from '@stacksjs/orm'
 
 import Coupon from './Coupon'
 
+import Order from './Order'
 
 import User from './User'
 
@@ -581,7 +583,14 @@ export class OrderModel {
   }
 
   async pluck<K extends keyof OrderModel>(field: K): Promise<OrderModel[K][]> {
-    return OrderModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: OrderModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: OrderModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/OrderItem.ts b/storage/framework/orm/src/models/OrderItem.ts
@@ -482,7 +482,14 @@ export class OrderItemModel {
   }
 
   async pluck<K extends keyof OrderItemModel>(field: K): Promise<OrderItemModel[K][]> {
-    return OrderItemModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: OrderItemModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: OrderItemModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/PaymentMethod.ts b/storage/framework/orm/src/models/PaymentMethod.ts
@@ -521,7 +521,14 @@ export class PaymentMethodModel {
   }
 
   async pluck<K extends keyof PaymentMethodModel>(field: K): Promise<PaymentMethodModel[K][]> {
-    return PaymentMethodModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: PaymentMethodModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: PaymentMethodModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/PaymentProduct.ts b/storage/framework/orm/src/models/PaymentProduct.ts
@@ -501,7 +501,14 @@ export class PaymentProductModel {
   }
 
   async pluck<K extends keyof PaymentProductModel>(field: K): Promise<PaymentProductModel[K][]> {
-    return PaymentProductModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: PaymentProductModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: PaymentProductModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/PaymentTransaction.ts b/storage/framework/orm/src/models/PaymentTransaction.ts
@@ -510,7 +510,14 @@ export class PaymentTransactionModel {
   }
 
   async pluck<K extends keyof PaymentTransactionModel>(field: K): Promise<PaymentTransactionModel[K][]> {
-    return PaymentTransactionModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: PaymentTransactionModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: PaymentTransactionModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Post.ts b/storage/framework/orm/src/models/Post.ts
@@ -459,7 +459,14 @@ export class PostModel {
   }
 
   async pluck<K extends keyof PostModel>(field: K): Promise<PostModel[K][]> {
-    return PostModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: PostModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: PostModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Product.ts b/storage/framework/orm/src/models/Product.ts
@@ -542,7 +542,14 @@ export class ProductModel {
   }
 
   async pluck<K extends keyof ProductModel>(field: K): Promise<ProductModel[K][]> {
-    return ProductModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: ProductModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: ProductModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/ProductCategory.ts b/storage/framework/orm/src/models/ProductCategory.ts
@@ -499,7 +499,14 @@ export class ProductCategoryModel {
   }
 
   async pluck<K extends keyof ProductCategoryModel>(field: K): Promise<ProductCategoryModel[K][]> {
-    return ProductCategoryModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: ProductCategoryModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: ProductCategoryModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Project.ts b/storage/framework/orm/src/models/Project.ts
@@ -464,7 +464,14 @@ export class ProjectModel {
   }
 
   async pluck<K extends keyof ProjectModel>(field: K): Promise<ProjectModel[K][]> {
-    return ProjectModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: ProjectModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: ProjectModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Release.ts b/storage/framework/orm/src/models/Release.ts
@@ -437,7 +437,14 @@ export class ReleaseModel {
   }
 
   async pluck<K extends keyof ReleaseModel>(field: K): Promise<ReleaseModel[K][]> {
-    return ReleaseModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: ReleaseModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: ReleaseModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Request.ts b/storage/framework/orm/src/models/Request.ts
@@ -518,7 +518,14 @@ export class RequestModel {
   }
 
   async pluck<K extends keyof RequestModel>(field: K): Promise<RequestModel[K][]> {
-    return RequestModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: RequestModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: RequestModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Subscriber.ts b/storage/framework/orm/src/models/Subscriber.ts
@@ -437,7 +437,14 @@ export class SubscriberModel {
   }
 
   async pluck<K extends keyof SubscriberModel>(field: K): Promise<SubscriberModel[K][]> {
-    return SubscriberModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: SubscriberModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: SubscriberModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/SubscriberEmail.ts b/storage/framework/orm/src/models/SubscriberEmail.ts
@@ -455,7 +455,14 @@ export class SubscriberEmailModel {
   }
 
   async pluck<K extends keyof SubscriberEmailModel>(field: K): Promise<SubscriberEmailModel[K][]> {
-    return SubscriberEmailModel.pluck(field)
+    if (this.hasSelect) {
+      const model = await this.selectFromQuery.execute()
+      return model.map((modelItem: SubscriberEmailModel) => modelItem[field])
+    }
+
+    const model = await this.selectFromQuery.selectAll().execute()
+
+    return model.map((modelItem: SubscriberEmailModel) => modelItem[field])
   }
 
   static async count(): Promise<number> {
diff --git a/storage/framework/orm/src/models/Subscription.ts b/storage/framework/orm/src/models/Subscription.ts
diff --git a/storage/framework/orm/src/models/Team.ts b/storage/framework/orm/src/models/Team.ts
diff --git a/storage/framework/orm/src/models/Transaction.ts b/storage/framework/orm/src/models/Transaction.ts
diff --git a/storage/framework/orm/src/models/User.ts b/storage/framework/orm/src/models/User.ts
diff --git a/storage/framework/server-auto-imports.json b/storage/framework/server-auto-imports.json
diff --git a/storage/framework/types/server-auto-imports.d.ts b/storage/framework/types/server-auto-imports.d.ts

Original file line number	Diff line number	Diff line change
`@@ -1328,7 +1328,14 @@ export async function generateModelString(`
`1328`	`1328`	`}`
`1329`	`1329`
`1330`	`1330`	`async pluck<K extends keyof ${modelName}Model>(field: K): Promise<${modelName}Model[K][]> {`
`1331`		`- return ${modelName}Model.pluck(field)`
	`1331`	`+ if (this.hasSelect) {`
	`1332`	`+ const model = await this.selectFromQuery.execute()`
	`1333`	`+ return model.map((modelItem: ${modelName}Model) => modelItem[field])`
	`1334`	`+ }`
	`1335`	`+`
	`1336`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`1337`	`+`
	`1338`	`+ return model.map((modelItem: ${modelName}Model) => modelItem[field])`
`1332`	`1339`	`}`
`1333`	`1340`
`1334`	`1341`	`static async count(): Promise<number> {`
Original file line number	Diff line number	Diff line change
`@@ -545,7 +545,14 @@ export class AccessTokenModel {`
`545`	`545`	`}`
`546`	`546`
`547`	`547`	`async pluck<K extends keyof AccessTokenModel>(field: K): Promise<AccessTokenModel[K][]> {`
`548`		`- return AccessTokenModel.pluck(field)`
	`548`	`+ if (this.hasSelect) {`
	`549`	`+ const model = await this.selectFromQuery.execute()`
	`550`	`+ return model.map((modelItem: AccessTokenModel) => modelItem[field])`
	`551`	`+ }`
	`552`	`+`
	`553`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`554`	`+`
	`555`	`+ return model.map((modelItem: AccessTokenModel) => modelItem[field])`
`549`	`556`	`}`
`550`	`557`
`551`	`558`	`static async count(): Promise<number> {`
Original file line number	Diff line number	Diff line change
`@@ -585,7 +585,14 @@ export class CouponModel {`
`585`	`585`	`}`
`586`	`586`
`587`	`587`	`async pluck<K extends keyof CouponModel>(field: K): Promise<CouponModel[K][]> {`
`588`		`- return CouponModel.pluck(field)`
	`588`	`+ if (this.hasSelect) {`
	`589`	`+ const model = await this.selectFromQuery.execute()`
	`590`	`+ return model.map((modelItem: CouponModel) => modelItem[field])`
	`591`	`+ }`
	`592`	`+`
	`593`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`594`	`+`
	`595`	`+ return model.map((modelItem: CouponModel) => modelItem[field])`
`589`	`596`	`}`
`590`	`597`
`591`	`598`	`static async count(): Promise<number> {`
Original file line number	Diff line number	Diff line change
`@@ -530,7 +530,14 @@ export class CustomerModel {`
`530`	`530`	`}`
`531`	`531`
`532`	`532`	`async pluck<K extends keyof CustomerModel>(field: K): Promise<CustomerModel[K][]> {`
`533`		`- return CustomerModel.pluck(field)`
	`533`	`+ if (this.hasSelect) {`
	`534`	`+ const model = await this.selectFromQuery.execute()`
	`535`	`+ return model.map((modelItem: CustomerModel) => modelItem[field])`
	`536`	`+ }`
	`537`	`+`
	`538`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`539`	`+`
	`540`	`+ return model.map((modelItem: CustomerModel) => modelItem[field])`
`534`	`541`	`}`
`535`	`542`
`536`	`543`	`static async count(): Promise<number> {`
Original file line number	Diff line number	Diff line change
`@@ -514,7 +514,14 @@ export class DeploymentModel {`
`514`	`514`	`}`
`515`	`515`
`516`	`516`	`async pluck<K extends keyof DeploymentModel>(field: K): Promise<DeploymentModel[K][]> {`
`517`		`- return DeploymentModel.pluck(field)`
	`517`	`+ if (this.hasSelect) {`
	`518`	`+ const model = await this.selectFromQuery.execute()`
	`519`	`+ return model.map((modelItem: DeploymentModel) => modelItem[field])`
	`520`	`+ }`
	`521`	`+`
	`522`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`523`	`+`
	`524`	`+ return model.map((modelItem: DeploymentModel) => modelItem[field])`
`518`	`525`	`}`
`519`	`526`
`520`	`527`	`static async count(): Promise<number> {`
Original file line number	Diff line number	Diff line change
`@@ -473,7 +473,14 @@ export class ErrorModel {`
`473`	`473`	`}`
`474`	`474`
`475`	`475`	`async pluck<K extends keyof ErrorModel>(field: K): Promise<ErrorModel[K][]> {`
`476`		`- return ErrorModel.pluck(field)`
	`476`	`+ if (this.hasSelect) {`
	`477`	`+ const model = await this.selectFromQuery.execute()`
	`478`	`+ return model.map((modelItem: ErrorModel) => modelItem[field])`
	`479`	`+ }`
	`480`	`+`
	`481`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`482`	`+`
	`483`	`+ return model.map((modelItem: ErrorModel) => modelItem[field])`
`477`	`484`	`}`
`478`	`485`
`479`	`486`	`static async count(): Promise<number> {`
Original file line number	Diff line number	Diff line change
`@@ -473,7 +473,14 @@ export class FailedJobModel {`
`473`	`473`	`}`
`474`	`474`
`475`	`475`	`async pluck<K extends keyof FailedJobModel>(field: K): Promise<FailedJobModel[K][]> {`
`476`		`- return FailedJobModel.pluck(field)`
	`476`	`+ if (this.hasSelect) {`
	`477`	`+ const model = await this.selectFromQuery.execute()`
	`478`	`+ return model.map((modelItem: FailedJobModel) => modelItem[field])`
	`479`	`+ }`
	`480`	`+`
	`481`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`482`	`+`
	`483`	`+ return model.map((modelItem: FailedJobModel) => modelItem[field])`
`477`	`484`	`}`
`478`	`485`
`479`	`486`	`static async count(): Promise<number> {`
Original file line number	Diff line number	Diff line change
`@@ -594,7 +594,14 @@ export class GiftCardModel {`
`594`	`594`	`}`
`595`	`595`
`596`	`596`	`async pluck<K extends keyof GiftCardModel>(field: K): Promise<GiftCardModel[K][]> {`
`597`		`- return GiftCardModel.pluck(field)`
	`597`	`+ if (this.hasSelect) {`
	`598`	`+ const model = await this.selectFromQuery.execute()`
	`599`	`+ return model.map((modelItem: GiftCardModel) => modelItem[field])`
	`600`	`+ }`
	`601`	`+`
	`602`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`603`	`+`
	`604`	`+ return model.map((modelItem: GiftCardModel) => modelItem[field])`
`598`	`605`	`}`
`599`	`606`
`600`	`607`	`static async count(): Promise<number> {`
Original file line number	Diff line number	Diff line change
`@@ -473,7 +473,14 @@ export class JobModel {`
`473`	`473`	`}`
`474`	`474`
`475`	`475`	`async pluck<K extends keyof JobModel>(field: K): Promise<JobModel[K][]> {`
`476`		`- return JobModel.pluck(field)`
	`476`	`+ if (this.hasSelect) {`
	`477`	`+ const model = await this.selectFromQuery.execute()`
	`478`	`+ return model.map((modelItem: JobModel) => modelItem[field])`
	`479`	`+ }`
	`480`	`+`
	`481`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`482`	`+`
	`483`	`+ return model.map((modelItem: JobModel) => modelItem[field])`
`477`	`484`	`}`
`478`	`485`
`479`	`486`	`static async count(): Promise<number> {`
Original file line number	Diff line number	Diff line change
`@@ -502,7 +502,14 @@ export class LoyaltyPointModel {`
`502`	`502`	`}`
`503`	`503`
`504`	`504`	`async pluck<K extends keyof LoyaltyPointModel>(field: K): Promise<LoyaltyPointModel[K][]> {`
`505`		`- return LoyaltyPointModel.pluck(field)`
	`505`	`+ if (this.hasSelect) {`
	`506`	`+ const model = await this.selectFromQuery.execute()`
	`507`	`+ return model.map((modelItem: LoyaltyPointModel) => modelItem[field])`
	`508`	`+ }`
	`509`	`+`
	`510`	`+ const model = await this.selectFromQuery.selectAll().execute()`
	`511`	`+`
	`512`	`+ return model.map((modelItem: LoyaltyPointModel) => modelItem[field])`
`506`	`513`	`}`
`507`	`514`
`508`	`515`	`static async count(): Promise<number> {`