Merge pull request #198 from AthennaIO/develop

feat: add pluck and pluckMany methods

Author: jlenon7

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/database",
-  "version": "5.19.0",
+  "version": "5.20.0",
   "description": "The Athenna database handler for SQL/NoSQL.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",

package.json

@@ -146,6 +146,24 @@ export class QueryBuilder<
     return this.driver.findOr(callback)
   }
 
+  /**
+   * Find value in database but returns only the value of
+   * selected column directly.
+   */
+  public async pluck<K extends keyof T = keyof T>(column: K): Promise<T[K]> {
+    return this.driver.pluck(column)
+  }
+
+  /**
+   * Find many values in database but returns only the
+   * values of selected column directly.
+   */
+  public async pluckMany<K extends keyof T = keyof T>(
+    column: K
+  ): Promise<T[K][]> {
+    return this.driver.pluckMany(column)
+  }
+
   /**
    * Find a value in database.
    */

src/database/builders/QueryBuilder.ts

@@ -380,6 +380,30 @@ export abstract class Driver<Client = any, QB = any> {
     return data
   }
 
+  /**
+   * Find value in database but returns only the value of
+   * selected column directly.
+   */
+  public async pluck<T = any, K extends keyof T = keyof T>(
+    column: K
+  ): Promise<T[K]> {
+    const data = await this.find()
+
+    return data[column]
+  }
+
+  /**
+   * Find many values in database but returns only the
+   * values of selected column directly.
+   */
+  public async pluckMany<T = any, K extends keyof T = keyof T>(
+    column: K
+  ): Promise<T[K][]> {
+    const data = await this.findMany()
+
+    return data.map(d => d[column])
+  }
+
   /**
    * Find a value in database.
    */

src/database/drivers/Driver.ts

@@ -323,6 +323,22 @@ export class FakeDriver {
     return '1'
   }
 
+  /**
+   * Find value in database but returns only the value of
+   * selected column directly.
+   */
+  public static async pluck(): Promise<any> {
+    return ''
+  }
+
+  /**
+   * Find many values in database but returns only the
+   * values of selected column directly.
+   */
+  public static async pluckMany(): Promise<any> {
+    return ['']
+  }
+
   /**
    * Find a value in database.
    */

src/database/drivers/FakeDriver.ts

@@ -197,6 +197,48 @@ export class BaseModel {
     await Database.connection(this.connection()).truncate(this.table())
   }
 
+  /**
+   * Find value in database but returns only the value of
+   * selected column directly.
+   */
+  public static async pluck<
+    T extends typeof BaseModel,
+    K extends keyof InstanceType<T> = keyof InstanceType<T>
+  >(
+    this: T,
+    key: K,
+    where?: Partial<InstanceType<T>>
+  ): Promise<InstanceType<T>[K]> {
+    const query = this.query()
+
+    if (where) {
+      query.where(where)
+    }
+
+    return query.pluck(key)
+  }
+
+  /**
+   * Find many values in database but returns only the
+   * values of selected column directly.
+   */
+  public static async pluckMany<
+    T extends typeof BaseModel,
+    K extends keyof InstanceType<T> = keyof InstanceType<T>
+  >(
+    this: T,
+    key: K,
+    where?: Partial<InstanceType<T>>
+  ): Promise<InstanceType<T>[K][]> {
+    const query = this.query()
+
+    if (where) {
+      query.where(where)
+    }
+
+    return query.pluckMany(key)
+  }
+
   /**
    * Find a value in database.
    */

src/models/BaseModel.ts

@@ -181,6 +181,34 @@ export class ModelQueryBuilder<
     return super.countDistinct(name as any)
   }
 
+  /**
+   * Find value in database but returns only the value of
+   * selected column directly.
+   */
+  public async pluck<K extends keyof M = ModelColumns<M>>(
+    column: K
+  ): Promise<M[K]> {
+    this.setInternalQueries()
+
+    const columnName: any = this.schema.getColumnNameByProperty(column as any)
+
+    return super.pluck(columnName)
+  }
+
+  /**
+   * Find many values in database but returns only the
+   * values of selected column directly.
+   */
+  public async pluckMany<K extends keyof M = ModelColumns<M>>(
+    column: K
+  ): Promise<M[K][]> {
+    this.setInternalQueries()
+
+    const columnName: any = this.schema.getColumnNameByProperty(column as any)
+
+    return super.pluckMany(columnName)
+  }
+
   /**
    * Find a value in database.
    */

src/models/builders/ModelQueryBuilder.ts

@@ -228,6 +228,30 @@ export default class QueryBuilderTest {
     assert.deepEqual(result, expectedData)
   }
 
+  @Test()
+  public async shouldBeAbleToPluckData({ assert }: Context) {
+    const expectedData = 'John Doe'
+    Mock.when(FakeDriver, 'pluck').resolve(expectedData)
+
+    const queryBuilder = new QueryBuilder(FakeDriver, 'users')
+    const result = await queryBuilder.pluck('name')
+
+    assert.calledOnce(FakeDriver.pluck)
+    assert.deepEqual(result, 'John Doe')
+  }
+
+  @Test()
+  public async shouldBeAbleToPluckManyData({ assert }: Context) {
+    const expectedData = ['John Doe', 'Jane Doe']
+    Mock.when(FakeDriver, 'pluckMany').resolve(expectedData)
+
+    const queryBuilder = new QueryBuilder(FakeDriver, 'users')
+    const result = await queryBuilder.pluckMany('name')
+
+    assert.calledOnce(FakeDriver.pluckMany)
+    assert.deepEqual(result, ['John Doe', 'Jane Doe'])
+  }
+
   @Test()
   public async shouldBeAbleToFindManyDataUsingCollection({ assert }: Context) {
     const expectedData = [

tests/unit/database/builders/QueryBuilderTest.ts

@@ -659,6 +659,26 @@ export default class MongoDriverTest {
     assert.containsSubset(result, data)
   }
 
+  @Test()
+  public async shouldBeAbleToPluckDataUsingDriver({ assert }: Context) {
+    const data = { _id: '1', name: 'Charles Babbage' }
+    await this.driver.table('users').create(data)
+
+    const result = await this.driver.table('users').pluck('name')
+
+    assert.containsSubset(result, 'Charles Babbage')
+  }
+
+  @Test()
+  public async shouldBeAbleToPluckManyDataUsingDriver({ assert }: Context) {
+    const data = [{ _id: '1', name: 'Charles Babbage' }]
+    await this.driver.table('users').createMany(data)
+
+    const result = await this.driver.table('users').pluckMany('name')
+
+    assert.containsSubset(result, ['Charles Babbage'])
+  }
+
   @Test()
   public async shouldReturnEmptyArrayWhenFindManyMethodCantFindNothing({ assert }: Context) {
     const result = await this.driver.table('users').findMany()

tests/unit/drivers/MongoDriverTest.ts

@@ -708,6 +708,26 @@ export default class MySqlDriverTest {
     assert.containsSubset(result, data)
   }
 
+  @Test()
+  public async shouldBeAbleToPluckDataUsingDriver({ assert }: Context) {
+    const data = { id: '1', name: 'Charles Babbage' }
+    await this.driver.table('users').create(data)
+
+    const result = await this.driver.table('users').pluck('name')
+
+    assert.containsSubset(result, 'Charles Babbage')
+  }
+
+  @Test()
+  public async shouldBeAbleToPluckManyDataUsingDriver({ assert }: Context) {
+    const data = [{ id: '1', name: 'Charles Babbage' }]
+    await this.driver.table('users').createMany(data)
+
+    const result = await this.driver.table('users').pluckMany('name')
+
+    assert.containsSubset(result, ['Charles Babbage'])
+  }
+
   @Test()
   public async shouldReturnEmptyArrayWhenFindManyMethodCantFindNothing({ assert }: Context) {
     const result = await this.driver.table('users').findMany()