@naturalcycles/db-lib 8.28.0 → 8.30.0

package/dist/commondao/common.dao.d.ts

@@ -13,11 +13,11 @@ import { CommonDaoCfg, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOp
 export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends ObjectWithId = Saved<BM>, TM = BM> {
     cfg: CommonDaoCfg<BM, DBM, TM>;
     constructor(cfg: CommonDaoCfg<BM, DBM, TM>);
-    create(part: Partial<BM>, opt?: CommonDaoOptions): Saved<BM>;
+    create(part?: Partial<BM>, opt?: CommonDaoOptions): Saved<BM>;
     getById(id: undefined, opt?: CommonDaoOptions): Promise<null>;
     getById(id?: string, opt?: CommonDaoOptions): Promise<Saved<BM> | null>;
-    getByIdOrEmpty(id: string, part: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    getByIdAsDBMOrEmpty(id: string, part: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM>;
+    getByIdOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
+    getByIdAsDBMOrEmpty(id: string, part?: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM>;
     getByIdAsDBM(id: undefined, opt?: CommonDaoOptions): Promise<null>;
     getByIdAsDBM(id?: string, opt?: CommonDaoOptions): Promise<DBM | null>;
     getByIdAsTM(id: undefined, opt?: CommonDaoOptions): Promise<null>;
@@ -39,6 +39,7 @@ export declare class CommonDao<BM extends Partial<ObjectWithId>, DBM extends Obj
      */
     query(table?: string): RunnableDBQuery<BM, DBM, TM>;
     runQuery(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    runQuerySingleColumn<T = any>(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<T[]>;
     /**
      * Convenience method that runs multiple queries in parallel and then merges their results together.
      * Does deduplication by id.

package/dist/commondao/common.dao.js

@@ -44,7 +44,7 @@ class CommonDao {
         };
     }
     // CREATE
-    create(part, opt = {}) {
+    create(part = {}, opt = {}) {
         let bm = this.cfg.hooks.beforeCreate(part);
         bm = this.validateAndConvert(bm, this.cfg.bmSchema, db_model_1.DBModelType.BM, opt);
         // If no SCHEMA - return as is
@@ -71,13 +71,13 @@ class CommonDao {
         this.logResult(started, op, bm, table);
         return bm || null;
     }
-    async getByIdOrEmpty(id, part, opt) {
+    async getByIdOrEmpty(id, part = {}, opt) {
         const bm = await this.getById(id, opt);
         if (bm)
             return bm;
         return this.create({ ...part, id }, opt);
     }
-    async getByIdAsDBMOrEmpty(id, part, opt) {
+    async getByIdAsDBMOrEmpty(id, part = {}, opt) {
         const dbm = await this.getByIdAsDBM(id, opt);
         if (dbm)
             return dbm;
@@ -184,6 +184,12 @@ class CommonDao {
         const { rows } = await this.runQueryExtended(q, opt);
         return rows;
     }
+    async runQuerySingleColumn(q, opt) {
+        (0, js_lib_1._assert)(q._selectedFieldNames?.length === 1, `runQuerySingleColumn requires exactly 1 column to be selected: ${q.pretty()}`);
+        const col = q._selectedFieldNames[0];
+        const { rows } = await this.runQueryExtended(q, opt);
+        return rows.map(r => r[col]);
+    }
     /**
      * Convenience method that runs multiple queries in parallel and then merges their results together.
      * Does deduplication by id.

package/dist/query/dbQuery.d.ts

@@ -64,12 +64,16 @@ export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
      * In undefined - all fields (*) will be returned.
      */
     _selectedFieldNames?: (keyof ROW)[];
+    _groupByFieldNames?: (keyof ROW)[];
+    _distinct: boolean;
     filter(name: keyof ROW, op: DBQueryFilterOperator, val: any): this;
     filterEq(name: keyof ROW, val: any): this;
     limit(limit: number): this;
     offset(offset: number): this;
     order(name: keyof ROW, descending?: boolean): this;
     select(fieldNames: (keyof ROW)[]): this;
+    groupBy(fieldNames: (keyof ROW)[]): this;
+    distinct(distinct?: boolean): this;
     startCursor(startCursor?: string): this;
     endCursor(endCursor?: string): this;
     clone(): DBQuery<ROW>;
@@ -86,6 +90,7 @@ export declare class RunnableDBQuery<BM extends Partial<ObjectWithId>, DBM exten
      */
     constructor(dao: CommonDao<BM, DBM, TM>, table?: string);
     runQuery(opt?: CommonDaoOptions): Promise<Saved<BM>[]>;
+    runQuerySingleColumn<T = any>(opt?: CommonDaoOptions): Promise<T[]>;
     runQueryAsDBM(opt?: CommonDaoOptions): Promise<DBM[]>;
     runQueryAsTM(opt?: CommonDaoOptions): Promise<TM[]>;
     runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<BM>>>;

package/dist/query/dbQuery.js

@@ -30,6 +30,7 @@ class DBQuery {
         this._limitValue = 0; // 0 means "no limit"
         this._offsetValue = 0; // 0 means "no offset"
         this._orders = [];
+        this._distinct = false;
     }
     /**
      * Convenience method.
@@ -67,6 +68,14 @@ class DBQuery {
         this._selectedFieldNames = fieldNames;
         return this;
     }
+    groupBy(fieldNames) {
+        this._groupByFieldNames = fieldNames;
+        return this;
+    }
+    distinct(distinct = true) {
+        this._distinct = distinct;
+        return this;
+    }
     startCursor(startCursor) {
         this._startCursor = startCursor;
         return this;
@@ -82,6 +91,8 @@ class DBQuery {
             _offsetValue: this._offsetValue,
             _orders: [...this._orders],
             _selectedFieldNames: this._selectedFieldNames && [...this._selectedFieldNames],
+            _groupByFieldNames: this._groupByFieldNames && [...this._groupByFieldNames],
+            _distinct: this._distinct,
             _startCursor: this._startCursor,
             _endCursor: this._endCursor,
         });
@@ -95,9 +106,12 @@ class DBQuery {
         //   tokens.push(`"${this.name}"`)
         // }
         if (this._selectedFieldNames) {
-            tokens.push(`select(${this._selectedFieldNames.join(',')})`);
+            tokens.push(`select${this._distinct ? ' distinct' : ''}(${this._selectedFieldNames.join(',')})`);
         }
         tokens.push(...this._filters.map(f => `${f.name}${f.op}${f.val}`), ...this._orders.map(o => `order by ${o.name}${o.descending ? ' desc' : ''}`));
+        if (this._groupByFieldNames) {
+            tokens.push(`groupBy(${this._groupByFieldNames.join(',')})`);
+        }
         if (this._offsetValue) {
             tokens.push(`offset ${this._offsetValue}`);
         }
@@ -128,6 +142,9 @@ class RunnableDBQuery extends DBQuery {
     async runQuery(opt) {
         return await this.dao.runQuery(this, opt);
     }
+    async runQuerySingleColumn(opt) {
+        return await this.dao.runQuerySingleColumn(this, opt);
+    }
     async runQueryAsDBM(opt) {
         return await this.dao.runQueryAsDBM(this, opt);
     }

package/package.json

@@ -43,7 +43,7 @@
   "engines": {
     "node": ">=14.15"
   },
-  "version": "8.28.0",
+  "version": "8.30.0",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/commondao/common.dao.ts

@@ -1,4 +1,5 @@
 import {
+  _assert,
   _filterNullishValues,
   _filterUndefinedValues,
   _passthroughPredicate,
@@ -88,7 +89,7 @@ export class CommonDao<
   }
 
   // CREATE
-  create(part: Partial<BM>, opt: CommonDaoOptions = {}): Saved<BM> {
+  create(part: Partial<BM> = {}, opt: CommonDaoOptions = {}): Saved<BM> {
     let bm = this.cfg.hooks!.beforeCreate!(part) as BM
     bm = this.validateAndConvert(bm, this.cfg.bmSchema, DBModelType.BM, opt)
 
@@ -124,14 +125,22 @@ export class CommonDao<
     return bm || null
   }
 
-  async getByIdOrEmpty(id: string, part: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>> {
+  async getByIdOrEmpty(
+    id: string,
+    part: Partial<BM> = {},
+    opt?: CommonDaoOptions,
+  ): Promise<Saved<BM>> {
     const bm = await this.getById(id, opt)
     if (bm) return bm
 
     return this.create({ ...part, id }, opt)
   }
 
-  async getByIdAsDBMOrEmpty(id: string, part: Partial<BM>, opt?: CommonDaoOptions): Promise<DBM> {
+  async getByIdAsDBMOrEmpty(
+    id: string,
+    part: Partial<BM> = {},
+    opt?: CommonDaoOptions,
+  ): Promise<DBM> {
     const dbm = await this.getByIdAsDBM(id, opt)
     if (dbm) return dbm
 
@@ -254,6 +263,18 @@ export class CommonDao<
     return rows
   }
 
+  async runQuerySingleColumn<T = any>(q: DBQuery<DBM>, opt?: CommonDaoOptions): Promise<T[]> {
+    _assert(
+      q._selectedFieldNames?.length === 1,
+      `runQuerySingleColumn requires exactly 1 column to be selected: ${q.pretty()}`,
+    )
+
+    const col = q._selectedFieldNames[0]!
+
+    const { rows } = await this.runQueryExtended(q, opt)
+    return rows.map(r => r[col as any])
+  }
+
   /**
    * Convenience method that runs multiple queries in parallel and then merges their results together.
    * Does deduplication by id.

package/src/query/dbQuery.ts

@@ -96,6 +96,8 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
    * In undefined - all fields (*) will be returned.
    */
   _selectedFieldNames?: (keyof ROW)[]
+  _groupByFieldNames?: (keyof ROW)[]
+  _distinct = false
 
   filter(name: keyof ROW, op: DBQueryFilterOperator, val: any): this {
     this._filters.push({ name, op, val })
@@ -130,6 +132,16 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     return this
   }
 
+  groupBy(fieldNames: (keyof ROW)[]): this {
+    this._groupByFieldNames = fieldNames
+    return this
+  }
+
+  distinct(distinct = true): this {
+    this._distinct = distinct
+    return this
+  }
+
   startCursor(startCursor?: string): this {
     this._startCursor = startCursor
     return this
@@ -147,6 +159,8 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
       _offsetValue: this._offsetValue,
       _orders: [...this._orders],
       _selectedFieldNames: this._selectedFieldNames && [...this._selectedFieldNames],
+      _groupByFieldNames: this._groupByFieldNames && [...this._groupByFieldNames],
+      _distinct: this._distinct,
       _startCursor: this._startCursor,
       _endCursor: this._endCursor,
     })
@@ -164,7 +178,9 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     // }
 
     if (this._selectedFieldNames) {
-      tokens.push(`select(${this._selectedFieldNames.join(',')})`)
+      tokens.push(
+        `select${this._distinct ? ' distinct' : ''}(${this._selectedFieldNames.join(',')})`,
+      )
     }
 
     tokens.push(
@@ -172,6 +188,10 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
       ...this._orders.map(o => `order by ${o.name}${o.descending ? ' desc' : ''}`),
     )
 
+    if (this._groupByFieldNames) {
+      tokens.push(`groupBy(${this._groupByFieldNames.join(',')})`)
+    }
+
     if (this._offsetValue) {
       tokens.push(`offset ${this._offsetValue}`)
     }
@@ -211,6 +231,10 @@ export class RunnableDBQuery<
     return await this.dao.runQuery(this, opt)
   }
 
+  async runQuerySingleColumn<T = any>(opt?: CommonDaoOptions): Promise<T[]> {
+    return await this.dao.runQuerySingleColumn<T>(this, opt)
+  }
+
   async runQueryAsDBM(opt?: CommonDaoOptions): Promise<DBM[]> {
     return await this.dao.runQueryAsDBM(this, opt)
   }