@naturalcycles/db-lib 8.29.0 → 8.33.0

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

@@ -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

@@ -25,7 +25,8 @@ class CommonDao {
             // otherwise to log Operations
             // e.g in Dev (local machine), Test - it will log operations (useful for debugging)
             logLevel: isGAE || isCI ? common_dao_model_1.CommonDaoLogLevel.NONE : common_dao_model_1.CommonDaoLogLevel.OPERATIONS,
-            createdUpdated: true,
+            created: true,
+            updated: true,
             logger: console,
             ...cfg,
             hooks: {
@@ -184,6 +185,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.
@@ -399,9 +406,13 @@ class CommonDao {
     assignIdCreatedUpdated(obj, opt = {}) {
         const now = Math.floor(Date.now() / 1000);
         obj.id = obj.id || this.cfg.hooks.createId(obj);
-        if (this.cfg.createdUpdated) {
+        if (this.cfg.created) {
             Object.assign(obj, {
                 created: obj.created || obj.updated || now,
+            });
+        }
+        if (this.cfg.updated) {
+            Object.assign(obj, {
                 updated: opt.preserveUpdatedCreated && obj.updated ? obj.updated : now,
             });
         }

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

@@ -76,10 +76,15 @@ export interface CommonDaoCfg<BM extends Partial<ObjectWithId>, DBM extends Obje
     logStarted?: boolean;
     hooks?: Partial<CommonDaoHooks<BM, DBM, TM>>;
     /**
-     * @default true
-     * Set to false to disable created/updated fields management.
+     * Defaults to true
+     * Set to false to disable `created` field management.
      */
-    createdUpdated?: boolean;
+    created?: boolean;
+    /**
+     * Defaults to true
+     * Set to false to disable `updated` field management.
+     */
+    updated?: boolean;
     /**
      * Default is false.
      * If true - will run `_filterNullishValues` inside `validateAndConvert` function

package/dist/index.d.ts

@@ -17,5 +17,6 @@ import { dbPipelineRestore, DBPipelineRestoreOptions } from './pipeline/dbPipeli
 import { DBQuery, DBQueryFilter, DBQueryFilterOperator, dbQueryFilterOperatorValues, DBQueryOrder, RunnableDBQuery } from './query/dbQuery';
 import { DBTransaction, RunnableDBTransaction } from './transaction/dbTransaction';
 import { commitDBTransactionSimple, mergeDBOperations } from './transaction/dbTransaction.util';
+export * from './kv/commonKeyValueDaoMemoCache';
 export type { DBQueryFilterOperator, DBQueryFilter, DBQueryOrder, CommonDaoCreateOptions, CommonDaoOptions, CommonDaoSaveOptions, CommonDaoStreamForEachOptions, CommonDaoStreamOptions, CommonDBOptions, CommonDBSaveOptions, CommonDBStreamOptions, CommonDBCreateOptions, CommonDB, RunQueryResult, CommonDaoCfg, CommonDaoCreateIdHook, CommonDaoParseNaturalIdHook, CommonDaoBeforeCreateHook, CommonDaoBeforeDBMValidateHook, CommonDaoBeforeDBMToBMHook, CommonDaoBeforeBMToDBMHook, CommonDaoBeforeTMToBMHook, CommonDaoBeforeBMToTMHook, CommonDaoAnonymizeHook, InMemoryDBCfg, InMemoryKeyValueDBCfg, DBPipelineBackupOptions, DBPipelineRestoreOptions, DBPipelineCopyOptions, CommonDBAdapter, DBOperation, DBSaveBatchOperation, DBDeleteByIdsOperation, CommonKeyValueDB, CommonKeyValueDaoCfg, KeyValueDBTuple, };
 export { DBQuery, dbQueryFilterOperatorValues, RunnableDBQuery, CommonDaoLogLevel, DBRelation, DBModelType, CommonDao, createdUpdatedFields, createdUpdatedIdFields, InMemoryDB, InMemoryKeyValueDB, queryInMemory, serializeJsonField, deserializeJsonField, dbPipelineBackup, dbPipelineRestore, dbPipelineCopy, getDB, DBLibError, BaseCommonDB, DBTransaction, RunnableDBTransaction, mergeDBOperations, commitDBTransactionSimple, CommonKeyValueDao, };

package/dist/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonKeyValueDao = exports.commitDBTransactionSimple = exports.mergeDBOperations = exports.RunnableDBTransaction = exports.DBTransaction = exports.BaseCommonDB = exports.DBLibError = exports.getDB = exports.dbPipelineCopy = exports.dbPipelineRestore = exports.dbPipelineBackup = exports.deserializeJsonField = exports.serializeJsonField = exports.queryInMemory = exports.InMemoryKeyValueDB = exports.InMemoryDB = exports.createdUpdatedIdFields = exports.createdUpdatedFields = exports.CommonDao = exports.DBModelType = exports.DBRelation = exports.CommonDaoLogLevel = exports.RunnableDBQuery = exports.dbQueryFilterOperatorValues = exports.DBQuery = void 0;
+const tslib_1 = require("tslib");
 const inMemory_db_1 = require("./adapter/inmemory/inMemory.db");
 Object.defineProperty(exports, "InMemoryDB", { enumerable: true, get: function () { return inMemory_db_1.InMemoryDB; } });
 const inMemoryKeyValueDB_1 = require("./adapter/inmemory/inMemoryKeyValueDB");
@@ -43,3 +44,4 @@ Object.defineProperty(exports, "RunnableDBTransaction", { enumerable: true, get:
 const dbTransaction_util_1 = require("./transaction/dbTransaction.util");
 Object.defineProperty(exports, "commitDBTransactionSimple", { enumerable: true, get: function () { return dbTransaction_util_1.commitDBTransactionSimple; } });
 Object.defineProperty(exports, "mergeDBOperations", { enumerable: true, get: function () { return dbTransaction_util_1.mergeDBOperations; } });
+(0, tslib_1.__exportStar)(require("./kv/commonKeyValueDaoMemoCache"), exports);

package/dist/kv/commonKeyValueDao.d.ts

@@ -25,6 +25,12 @@ export interface CommonKeyValueDaoCfg<T> {
         mapBufferToValue?: (b: Buffer) => Promise<T>;
         beforeCreate?: (v: Partial<T>) => Partial<T>;
     };
+    /**
+     * Set to `true` to conveniently enable zipping+JSON.stringify
+     * (and unzipping+JSON.parse) of the Buffer value via hooks.
+     * Custom hooks will override these hooks (if provided).
+     */
+    deflatedJsonValue?: boolean;
 }
 export declare class CommonKeyValueDao<T> {
     cfg: CommonKeyValueDaoCfg<T>;
@@ -33,6 +39,7 @@ export declare class CommonKeyValueDao<T> {
     createTable(opt?: CommonDBCreateOptions): Promise<void>;
     create(input?: Partial<T>): T;
     getById(id?: string): Promise<T | null>;
+    requireById(id: string): Promise<T>;
     getByIdOrEmpty(id: string, part?: Partial<T>): Promise<T>;
     patch(id: string, patch: Partial<T>): Promise<T>;
     getByIds(ids: string[]): Promise<KeyValueTuple<string, T>[]>;

package/dist/kv/commonKeyValueDao.js

@@ -3,11 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonKeyValueDao = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
 const nodejs_lib_1 = require("@naturalcycles/nodejs-lib");
+const cnst_1 = require("../cnst");
 // todo: logging
 // todo: readonly
 class CommonKeyValueDao {
     constructor(cfg) {
         this.cfg = cfg;
+        if (cfg.deflatedJsonValue) {
+            cfg.hooks = {
+                mapValueToBuffer: async (v) => await (0, nodejs_lib_1.deflateString)(JSON.stringify(v)),
+                mapBufferToValue: async (buf) => JSON.parse(await (0, nodejs_lib_1.inflateToString)(buf)),
+                ...cfg.hooks,
+            };
+        }
     }
     async ping() {
         await this.cfg.db.ping();
@@ -26,6 +34,18 @@ class CommonKeyValueDao {
         const [r] = await this.getByIds([id]);
         return r?.[1] || null;
     }
+    async requireById(id) {
+        const [r] = await this.getByIds([id]);
+        if (!r) {
+            const { table } = this.cfg;
+            throw new js_lib_1.AppError(`DB row required, but not found: ${table}.${id}`, {
+                code: cnst_1.DBLibError.DB_ROW_REQUIRED,
+                table,
+                id,
+            });
+        }
+        return r[1];
+    }
     async getByIdOrEmpty(id, part = {}) {
         const [r] = await this.getByIds([id]);
         if (r)

package/dist/kv/commonKeyValueDaoMemoCache.d.ts

@@ -0,0 +1,9 @@
+import { AsyncMemoCache } from '@naturalcycles/js-lib';
+import { CommonKeyValueDao } from './commonKeyValueDao';
+export declare class CommonKeyValueDaoMemoCache<VALUE = any> implements AsyncMemoCache<string, VALUE> {
+    private dao;
+    constructor(dao: CommonKeyValueDao<VALUE>);
+    get(k: string): Promise<VALUE | undefined>;
+    set(k: string, v: VALUE): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/kv/commonKeyValueDaoMemoCache.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonKeyValueDaoMemoCache = void 0;
+class CommonKeyValueDaoMemoCache {
+    constructor(dao) {
+        this.dao = dao;
+    }
+    async get(k) {
+        return (await this.dao.getById(k)) || undefined;
+    }
+    async set(k, v) {
+        await this.dao.save(k, v);
+    }
+    async clear() {
+        throw new Error('CommonKeyValueDaoCacheFactory.clear is not supported, because cache is expected to be persistent');
+    }
+}
+exports.CommonKeyValueDaoMemoCache = CommonKeyValueDaoMemoCache;

package/dist/query/dbQuery.d.ts

@@ -65,6 +65,7 @@ export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
      */
     _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;
@@ -72,6 +73,7 @@ export declare class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     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>;
@@ -88,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.
@@ -71,6 +72,10 @@ class DBQuery {
         this._groupByFieldNames = fieldNames;
         return this;
     }
+    distinct(distinct = true) {
+        this._distinct = distinct;
+        return this;
+    }
     startCursor(startCursor) {
         this._startCursor = startCursor;
         return this;
@@ -86,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,
         });
@@ -99,7 +106,7 @@ 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) {
@@ -135,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/dist/testing/test.model.d.ts

@@ -17,7 +17,7 @@ export interface TestItemTM {
 export declare const testItemBMSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<TestItemBM, TestItemBM>;
 export declare const testItemDBMSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<TestItemDBM, TestItemDBM>;
 export declare const testItemTMSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<TestItemTM, TestItemTM>;
-export declare const testItemBMJsonSchema: import("@naturalcycles/js-lib/dist/json-schema/jsonSchemaBuilder").JsonSchemaObjectBuilder<TestItemBM & Partial<import("@naturalcycles/js-lib").SavedDBEntity>>;
+export declare const testItemBMJsonSchema: import("@naturalcycles/js-lib/dist/json-schema/jsonSchemaBuilder").JsonSchemaObjectBuilder<TestItemBM & Partial<import("@naturalcycles/js-lib").SavedDBEntity<string>>>;
 export declare const testItemDBMJsonSchema: import("@naturalcycles/js-lib/dist/json-schema/jsonSchemaBuilder").JsonSchemaObjectBuilder<TestItemDBM>;
 export declare function createTestItemDBM(num?: number): TestItemDBM;
 export declare function createTestItemBM(num?: number): Saved<TestItemBM>;

package/dist/validation/index.d.ts

@@ -1,8 +1,8 @@
 import { CommonDBOptions, CommonDBSaveOptions } from '../db.model';
 import { DBQuery, DBQueryFilter, DBQueryOrder } from '../query/dbQuery';
 export declare const commonDBOptionsSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<CommonDBOptions, CommonDBOptions>;
-export declare const commonDBSaveOptionsSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<CommonDBSaveOptions<import("@naturalcycles/js-lib").AnyObjectWithId>, CommonDBSaveOptions<import("@naturalcycles/js-lib").AnyObjectWithId>>;
+export declare const commonDBSaveOptionsSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<CommonDBSaveOptions<import("@naturalcycles/js-lib").AnyObjectWithId<string>>, CommonDBSaveOptions<import("@naturalcycles/js-lib").AnyObjectWithId<string>>>;
 export declare const dbQueryFilterOperatorSchema: import("@naturalcycles/nodejs-lib/dist/validation/joi/string.extensions").ExtendedStringSchema;
-export declare const dbQueryFilterSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryFilter<import("@naturalcycles/js-lib").AnyObjectWithId>, DBQueryFilter<import("@naturalcycles/js-lib").AnyObjectWithId>>;
-export declare const dbQueryOrderSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryOrder<import("@naturalcycles/js-lib").AnyObjectWithId>, DBQueryOrder<import("@naturalcycles/js-lib").AnyObjectWithId>>;
+export declare const dbQueryFilterSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryFilter<import("@naturalcycles/js-lib").AnyObjectWithId<string>>, DBQueryFilter<import("@naturalcycles/js-lib").AnyObjectWithId<string>>>;
+export declare const dbQueryOrderSchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQueryOrder<import("@naturalcycles/js-lib").AnyObjectWithId<string>>, DBQueryOrder<import("@naturalcycles/js-lib").AnyObjectWithId<string>>>;
 export declare const dbQuerySchema: import("@naturalcycles/nodejs-lib").ObjectSchemaTyped<DBQuery<any>, DBQuery<any>>;

package/package.json

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

package/src/commondao/common.dao.model.ts

@@ -102,10 +102,16 @@ export interface CommonDaoCfg<
   hooks?: Partial<CommonDaoHooks<BM, DBM, TM>>
 
   /**
-   * @default true
-   * Set to false to disable created/updated fields management.
+   * Defaults to true
+   * Set to false to disable `created` field management.
    */
-  createdUpdated?: boolean
+  created?: boolean
+
+  /**
+   * Defaults to true
+   * Set to false to disable `updated` field management.
+   */
+  updated?: boolean
 
   /**
    * Default is false.

package/src/commondao/common.dao.ts

@@ -1,4 +1,5 @@
 import {
+  _assert,
   _filterNullishValues,
   _filterUndefinedValues,
   _passthroughPredicate,
@@ -68,7 +69,8 @@ export class CommonDao<
       // otherwise to log Operations
       // e.g in Dev (local machine), Test - it will log operations (useful for debugging)
       logLevel: isGAE || isCI ? CommonDaoLogLevel.NONE : CommonDaoLogLevel.OPERATIONS,
-      createdUpdated: true,
+      created: true,
+      updated: true,
       logger: console,
       ...cfg,
       hooks: {
@@ -262,6 +264,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.
@@ -549,9 +563,14 @@ export class CommonDao<
 
     obj.id = obj.id || this.cfg.hooks!.createId!(obj)
 
-    if (this.cfg.createdUpdated) {
+    if (this.cfg.created) {
       Object.assign(obj, {
         created: (obj as any).created || (obj as any).updated || now,
+      })
+    }
+
+    if (this.cfg.updated) {
+      Object.assign(obj, {
         updated: opt.preserveUpdatedCreated && (obj as any).updated ? (obj as any).updated : now,
       })
     }

package/src/index.ts

@@ -58,6 +58,7 @@ import {
 } from './query/dbQuery'
 import { DBTransaction, RunnableDBTransaction } from './transaction/dbTransaction'
 import { commitDBTransactionSimple, mergeDBOperations } from './transaction/dbTransaction.util'
+export * from './kv/commonKeyValueDaoMemoCache'
 
 export type {
   DBQueryFilterOperator,

package/src/kv/commonKeyValueDao.ts

@@ -1,5 +1,11 @@
-import { ErrorMode, KeyValueTuple, pMap } from '@naturalcycles/js-lib'
-import { ReadableTyped, transformMap } from '@naturalcycles/nodejs-lib'
+import { AppError, ErrorMode, KeyValueTuple, pMap } from '@naturalcycles/js-lib'
+import {
+  deflateString,
+  inflateToString,
+  ReadableTyped,
+  transformMap,
+} from '@naturalcycles/nodejs-lib'
+import { DBLibError } from '../cnst'
 import { CommonDaoLogLevel } from '../commondao/common.dao.model'
 import { CommonDBCreateOptions } from '../db.model'
 import { CommonKeyValueDB, KeyValueDBTuple } from './commonKeyValueDB'
@@ -30,13 +36,28 @@ export interface CommonKeyValueDaoCfg<T> {
     mapBufferToValue?: (b: Buffer) => Promise<T>
     beforeCreate?: (v: Partial<T>) => Partial<T>
   }
+
+  /**
+   * Set to `true` to conveniently enable zipping+JSON.stringify
+   * (and unzipping+JSON.parse) of the Buffer value via hooks.
+   * Custom hooks will override these hooks (if provided).
+   */
+  deflatedJsonValue?: boolean
 }
 
 // todo: logging
 // todo: readonly
 
 export class CommonKeyValueDao<T> {
-  constructor(public cfg: CommonKeyValueDaoCfg<T>) {}
+  constructor(public cfg: CommonKeyValueDaoCfg<T>) {
+    if (cfg.deflatedJsonValue) {
+      cfg.hooks = {
+        mapValueToBuffer: async v => await deflateString(JSON.stringify(v)),
+        mapBufferToValue: async buf => JSON.parse(await inflateToString(buf)),
+        ...cfg.hooks,
+      }
+    }
+  }
 
   async ping(): Promise<void> {
     await this.cfg.db.ping()
@@ -58,6 +79,21 @@ export class CommonKeyValueDao<T> {
     return r?.[1] || null
   }
 
+  async requireById(id: string): Promise<T> {
+    const [r] = await this.getByIds([id])
+
+    if (!r) {
+      const { table } = this.cfg
+      throw new AppError(`DB row required, but not found: ${table}.${id}`, {
+        code: DBLibError.DB_ROW_REQUIRED,
+        table,
+        id,
+      })
+    }
+
+    return r[1]
+  }
+
   async getByIdOrEmpty(id: string, part: Partial<T> = {}): Promise<T> {
     const [r] = await this.getByIds([id])
     if (r) return r[1]

package/src/kv/commonKeyValueDaoMemoCache.ts

@@ -0,0 +1,20 @@
+import { AsyncMemoCache } from '@naturalcycles/js-lib'
+import { CommonKeyValueDao } from './commonKeyValueDao'
+
+export class CommonKeyValueDaoMemoCache<VALUE = any> implements AsyncMemoCache<string, VALUE> {
+  constructor(private dao: CommonKeyValueDao<VALUE>) {}
+
+  async get(k: string): Promise<VALUE | undefined> {
+    return (await this.dao.getById(k)) || undefined
+  }
+
+  async set(k: string, v: VALUE): Promise<void> {
+    await this.dao.save(k, v)
+  }
+
+  async clear(): Promise<void> {
+    throw new Error(
+      'CommonKeyValueDaoCacheFactory.clear is not supported, because cache is expected to be persistent',
+    )
+  }
+}

package/src/query/dbQuery.ts

@@ -97,6 +97,7 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
    */
   _selectedFieldNames?: (keyof ROW)[]
   _groupByFieldNames?: (keyof ROW)[]
+  _distinct = false
 
   filter(name: keyof ROW, op: DBQueryFilterOperator, val: any): this {
     this._filters.push({ name, op, val })
@@ -136,6 +137,11 @@ export class DBQuery<ROW extends ObjectWithId = AnyObjectWithId> {
     return this
   }
 
+  distinct(distinct = true): this {
+    this._distinct = distinct
+    return this
+  }
+
   startCursor(startCursor?: string): this {
     this._startCursor = startCursor
     return this
@@ -153,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,
     })
@@ -170,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(
@@ -221,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)
   }