@naturalcycles/db-lib 8.25.0 → 8.28.1

package/dist/adapter/inmemory/inMemoryKeyValueDB.d.ts

@@ -17,4 +17,5 @@ export declare class InMemoryKeyValueDB implements CommonKeyValueDB {
     streamIds(table: string, limit?: number): ReadableTyped<string>;
     streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
     streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
+    count(table: string): Promise<number>;
 }

package/dist/adapter/inmemory/inMemoryKeyValueDB.js

@@ -34,5 +34,10 @@ class InMemoryKeyValueDB {
     streamEntries(table, limit) {
         return stream_1.Readable.from(Object.entries(this.data[table] || {}).slice(0, limit));
     }
+    async count(table) {
+        var _a;
+        (_a = this.data)[table] || (_a[table] = {});
+        return Object.keys(this.data[table]).length;
+    }
 }
 exports.InMemoryKeyValueDB = InMemoryKeyValueDB;

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

@@ -13,12 +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(input: 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>;
-    getByIdOrCreate(id: string, bmToCreate: Partial<BM>, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    getByIdOrEmpty(id: string, opt?: CommonDaoOptions): Promise<Saved<BM>>;
-    getByIdAsDBMOrEmpty(id: string, 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>;

package/dist/commondao/common.dao.js

@@ -44,8 +44,8 @@ class CommonDao {
         };
     }
     // CREATE
-    create(input, opt = {}) {
-        let bm = this.cfg.hooks.beforeCreate(input);
+    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
         return this.assignIdCreatedUpdated(bm, opt);
@@ -71,23 +71,17 @@ class CommonDao {
         this.logResult(started, op, bm, table);
         return bm || null;
     }
-    async getByIdOrCreate(id, bmToCreate, opt) {
+    async getByIdOrEmpty(id, part = {}, opt) {
         const bm = await this.getById(id, opt);
         if (bm)
             return bm;
-        return this.create({ ...bmToCreate, id }, opt);
+        return this.create({ ...part, id }, opt);
     }
-    async getByIdOrEmpty(id, opt) {
-        const bm = await this.getById(id, opt);
-        if (bm)
-            return bm;
-        return this.create({ id }, opt);
-    }
-    async getByIdAsDBMOrEmpty(id, opt) {
+    async getByIdAsDBMOrEmpty(id, part = {}, opt) {
         const dbm = await this.getByIdAsDBM(id, opt);
         if (dbm)
             return dbm;
-        const bm = this.create({ id }, opt);
+        const bm = this.create({ ...part, id }, opt);
         return await this.bmToDBM(bm, opt);
     }
     async getByIdAsDBM(id, opt = {}) {
@@ -458,7 +452,7 @@ class CommonDao {
      */
     async patch(id, patch, opt = {}) {
         return await this.save({
-            ...(await this.getByIdOrCreate(id, patch, opt)),
+            ...(await this.getByIdOrEmpty(id, patch, opt)),
             ...patch,
         }, opt);
     }

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

@@ -4,7 +4,7 @@ import { CommonDB } from '../common.db';
 import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../db.model';
 export declare type CommonDaoCreateIdHook<BM, DBM> = (obj: DBM | BM) => string;
 export declare type CommonDaoParseNaturalIdHook<DBM> = (id: string) => Partial<DBM>;
-export declare type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => BM;
+export declare type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => Partial<BM>;
 export declare type CommonDaoBeforeDBMValidateHook<DBM> = (dbm: Partial<DBM>) => Partial<DBM>;
 export declare type CommonDaoBeforeDBMToBMHook<BM, DBM> = (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>;
 export declare type CommonDaoBeforeBMToDBMHook<BM, DBM> = (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>;

package/dist/kv/commonKeyValueDB.d.ts

@@ -28,4 +28,5 @@ export interface CommonKeyValueDB {
     streamIds(table: string, limit?: number): ReadableTyped<string>;
     streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
     streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
+    count(table: string): Promise<number>;
 }

package/dist/kv/commonKeyValueDao.d.ts

@@ -21,8 +21,9 @@ export interface CommonKeyValueDaoCfg<T> {
      */
     logStarted?: boolean;
     hooks?: {
-        mapValueToBuffer(v: T): Promise<Buffer>;
-        mapBufferToValue(b: Buffer): Promise<T>;
+        mapValueToBuffer?: (v: T) => Promise<Buffer>;
+        mapBufferToValue?: (b: Buffer) => Promise<T>;
+        beforeCreate?: (v: Partial<T>) => Partial<T>;
     };
 }
 export declare class CommonKeyValueDao<T> {
@@ -30,11 +31,15 @@ export declare class CommonKeyValueDao<T> {
     constructor(cfg: CommonKeyValueDaoCfg<T>);
     ping(): Promise<void>;
     createTable(opt?: CommonDBCreateOptions): Promise<void>;
+    create(input?: Partial<T>): T;
     getById(id?: string): Promise<T | null>;
+    getByIdOrEmpty(id: string, part?: Partial<T>): Promise<T>;
+    patch(id: string, patch: Partial<T>): Promise<T>;
     getByIds(ids: string[]): Promise<KeyValueTuple<string, T>[]>;
     save(id: string, value: T): Promise<void>;
     saveBatch(entries: KeyValueTuple<string, T>[]): Promise<void>;
     deleteByIds(ids: string[]): Promise<void>;
+    deleteById(id: string): Promise<void>;
     streamIds(limit?: number): ReadableTyped<string>;
     streamValues(limit?: number): ReadableTyped<Buffer>;
     streamEntries(limit?: number): ReadableTyped<KeyValueTuple<string, T>>;

package/dist/kv/commonKeyValueDao.js

@@ -15,12 +15,34 @@ class CommonKeyValueDao {
     async createTable(opt = {}) {
         await this.cfg.db.createTable(this.cfg.table, opt);
     }
+    create(input = {}) {
+        return {
+            ...this.cfg.hooks?.beforeCreate?.(input),
+        };
+    }
     async getById(id) {
         if (!id)
             return null;
         const [r] = await this.getByIds([id]);
         return r?.[1] || null;
     }
+    async getByIdOrEmpty(id, part = {}) {
+        const [r] = await this.getByIds([id]);
+        if (r)
+            return r[1];
+        return {
+            ...this.cfg.hooks?.beforeCreate?.({}),
+            ...part,
+        };
+    }
+    async patch(id, patch) {
+        const v = {
+            ...(await this.getByIdOrEmpty(id)),
+            ...patch,
+        };
+        await this.save(id, v);
+        return v;
+    }
     async getByIds(ids) {
         const entries = await this.cfg.db.getByIds(this.cfg.table, ids);
         if (!this.cfg.hooks?.mapBufferToValue)
@@ -49,6 +71,9 @@ class CommonKeyValueDao {
     async deleteByIds(ids) {
         await this.cfg.db.deleteByIds(this.cfg.table, ids);
     }
+    async deleteById(id) {
+        await this.cfg.db.deleteByIds(this.cfg.table, [id]);
+    }
     streamIds(limit) {
         return this.cfg.db.streamIds(this.cfg.table, limit);
     }

package/dist/testing/dbTest.d.ts

@@ -18,6 +18,11 @@ export interface CommonDBImplementationFeatures {
     streaming?: boolean;
     bufferSupport?: boolean;
     nullValues?: boolean;
+    /**
+     * Set false for SQL (relational) databases,
+     * they will return `null` for all missing properties.
+     */
+    documentDB?: boolean;
 }
 /**
  * All options default to `false`.

package/dist/testing/dbTest.js

@@ -12,7 +12,7 @@ const test_util_1 = require("./test.util");
 function runCommonDBTest(db, features = {}, quirks = {}) {
     const { querying = true, tableSchemas = true, createTable = true, dbQueryFilter = true, 
     // dbQueryFilterIn = true,
-    dbQueryOrder = true, dbQuerySelectFields = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, } = features;
+    dbQueryOrder = true, dbQuerySelectFields = true, streaming = true, strongConsistency = true, bufferSupport = true, nullValues = true, documentDB = true, } = features;
     // const {
     // allowExtraPropertiesInResponse,
     // allowBooleansAsUndefined,
@@ -71,20 +71,22 @@ function runCommonDBTest(db, features = {}, quirks = {}) {
             expect(item3Loaded.k2).toBe(null);
         });
     }
-    test('undefined values should not be saved/loaded', async () => {
-        const item3 = {
-            ...(0, test_model_1.createTestItemDBM)(3),
-            k2: undefined,
-        };
-        (0, test_util_1.deepFreeze)(item3);
-        const expected = { ...item3 };
-        delete expected.k2;
-        await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
-        const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
-        expectMatch([expected], [item3Loaded], quirks);
-        expect(item3Loaded.k2).toBe(undefined);
-        expect(Object.keys(item3Loaded)).not.toContain('k2');
-    });
+    if (documentDB) {
+        test('undefined values should not be saved/loaded', async () => {
+            const item3 = {
+                ...(0, test_model_1.createTestItemDBM)(3),
+                k2: undefined,
+            };
+            (0, test_util_1.deepFreeze)(item3);
+            const expected = { ...item3 };
+            delete expected.k2;
+            await db.saveBatch(test_model_1.TEST_TABLE, [item3]);
+            const item3Loaded = (await db.getByIds(test_model_1.TEST_TABLE, [item3.id]))[0];
+            expectMatch([expected], [item3Loaded], quirks);
+            expect(item3Loaded.k2).toBe(undefined);
+            expect(Object.keys(item3Loaded)).not.toContain('k2');
+        });
+    }
     test('saveBatch test items', async () => {
         await db.saveBatch(test_model_1.TEST_TABLE, items);
     });

package/dist/testing/keyValueDBTest.js

@@ -20,12 +20,18 @@ function runCommonKeyValueDBTest(db) {
         const results = await db.getByIds(test_model_1.TEST_TABLE, testIds);
         expect(results).toEqual([]);
     });
+    test('count should be 0', async () => {
+        expect(await db.count(test_model_1.TEST_TABLE)).toBe(0);
+    });
     test('saveBatch, then getByIds', async () => {
         await db.saveBatch(test_model_1.TEST_TABLE, testEntries);
         const entries = await db.getByIds(test_model_1.TEST_TABLE, testIds);
         (0, js_lib_1._sortBy)(entries, e => e[0], true);
         expect(entries).toEqual(testEntries);
     });
+    test('count should be 3', async () => {
+        expect(await db.count(test_model_1.TEST_TABLE)).toBe(3);
+    });
     test('streamIds', async () => {
         const ids = await (0, nodejs_lib_1.readableToArray)(db.streamIds(test_model_1.TEST_TABLE));
         ids.sort();

package/package.json

@@ -13,7 +13,8 @@
     "@naturalcycles/bench-lib": "^1.0.0",
     "@naturalcycles/dev-lib": "^12.0.1",
     "@types/node": "^17.0.0",
-    "jest": "^27.0.3"
+    "jest": "^27.0.3",
+    "weak-napi": "^2.0.2"
   },
   "files": [
     "dist",
@@ -42,7 +43,7 @@
   "engines": {
     "node": ">=14.15"
   },
-  "version": "8.25.0",
+  "version": "8.28.1",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/adapter/inmemory/inMemoryKeyValueDB.ts

@@ -42,4 +42,9 @@ export class InMemoryKeyValueDB implements CommonKeyValueDB {
   streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple> {
     return Readable.from(Object.entries(this.data[table] || {}).slice(0, limit))
   }
+
+  async count(table: string): Promise<number> {
+    this.data[table] ||= {}
+    return Object.keys(this.data[table]!).length
+  }
 }

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

@@ -13,7 +13,7 @@ import { CommonDBCreateOptions, CommonDBOptions, CommonDBSaveOptions } from '../
 // Hook DBM, BM, TM types should follow this exact order
 export type CommonDaoCreateIdHook<BM, DBM> = (obj: DBM | BM) => string
 export type CommonDaoParseNaturalIdHook<DBM> = (id: string) => Partial<DBM>
-export type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => BM
+export type CommonDaoBeforeCreateHook<BM> = (bm: Partial<BM>) => Partial<BM>
 export type CommonDaoBeforeDBMValidateHook<DBM> = (dbm: Partial<DBM>) => Partial<DBM>
 export type CommonDaoBeforeDBMToBMHook<BM, DBM> = (dbm: DBM) => Partial<BM> | Promise<Partial<BM>>
 export type CommonDaoBeforeBMToDBMHook<BM, DBM> = (bm: BM) => Partial<DBM> | Promise<Partial<DBM>>

package/src/commondao/common.dao.ts

@@ -88,8 +88,8 @@ export class CommonDao<
   }
 
   // CREATE
-  create(input: Partial<BM>, opt: CommonDaoOptions = {}): Saved<BM> {
-    let bm = this.cfg.hooks!.beforeCreate!(input)
+  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)
 
     // If no SCHEMA - return as is
@@ -124,29 +124,26 @@ export class CommonDao<
     return bm || null
   }
 
-  async getByIdOrCreate(
+  async getByIdOrEmpty(
     id: string,
-    bmToCreate: Partial<BM>,
+    part: Partial<BM> = {},
     opt?: CommonDaoOptions,
   ): Promise<Saved<BM>> {
     const bm = await this.getById(id, opt)
     if (bm) return bm
 
-    return this.create({ ...bmToCreate, id }, opt)
+    return this.create({ ...part, id }, opt)
   }
 
-  async getByIdOrEmpty(id: string, opt?: CommonDaoOptions): Promise<Saved<BM>> {
-    const bm = await this.getById(id, opt)
-    if (bm) return bm
-
-    return this.create({ id } as Partial<BM>, opt)
-  }
-
-  async getByIdAsDBMOrEmpty(id: string, 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
 
-    const bm: BM = this.create({ id } as Partial<BM>, opt) as any
+    const bm: BM = this.create({ ...part, id }, opt) as any
     return await this.bmToDBM(bm, opt)
   }
 
@@ -614,7 +611,7 @@ export class CommonDao<
   ): Promise<Saved<BM>> {
     return await this.save(
       {
-        ...(await this.getByIdOrCreate(id, patch, opt)),
+        ...(await this.getByIdOrEmpty(id, patch, opt)),
         ...patch,
       } as any,
       opt,

package/src/kv/commonKeyValueDB.ts

@@ -34,4 +34,6 @@ export interface CommonKeyValueDB {
   streamIds(table: string, limit?: number): ReadableTyped<string>
   streamValues(table: string, limit?: number): ReadableTyped<Buffer>
   streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>
+
+  count(table: string): Promise<number>
 }

package/src/kv/commonKeyValueDao.ts

@@ -26,8 +26,9 @@ export interface CommonKeyValueDaoCfg<T> {
   logStarted?: boolean
 
   hooks?: {
-    mapValueToBuffer(v: T): Promise<Buffer>
-    mapBufferToValue(b: Buffer): Promise<T>
+    mapValueToBuffer?: (v: T) => Promise<Buffer>
+    mapBufferToValue?: (b: Buffer) => Promise<T>
+    beforeCreate?: (v: Partial<T>) => Partial<T>
   }
 }
 
@@ -45,19 +46,46 @@ export class CommonKeyValueDao<T> {
     await this.cfg.db.createTable(this.cfg.table, opt)
   }
 
+  create(input: Partial<T> = {}): T {
+    return {
+      ...this.cfg.hooks?.beforeCreate?.(input),
+    } as T
+  }
+
   async getById(id?: string): Promise<T | null> {
     if (!id) return null
     const [r] = await this.getByIds([id])
     return r?.[1] || null
   }
 
+  async getByIdOrEmpty(id: string, part: Partial<T> = {}): Promise<T> {
+    const [r] = await this.getByIds([id])
+    if (r) return r[1]
+
+    return {
+      ...this.cfg.hooks?.beforeCreate?.({}),
+      ...part,
+    } as T
+  }
+
+  async patch(id: string, patch: Partial<T>): Promise<T> {
+    const v: T = {
+      ...(await this.getByIdOrEmpty(id)),
+      ...patch,
+    }
+
+    await this.save(id, v)
+
+    return v
+  }
+
   async getByIds(ids: string[]): Promise<KeyValueTuple<string, T>[]> {
     const entries = await this.cfg.db.getByIds(this.cfg.table, ids)
     if (!this.cfg.hooks?.mapBufferToValue) return entries as any
 
     return await pMap(entries, async ([id, buf]) => [
       id,
-      await this.cfg.hooks!.mapBufferToValue(buf),
+      await this.cfg.hooks!.mapBufferToValue!(buf),
     ])
   }
 
@@ -73,7 +101,7 @@ export class CommonKeyValueDao<T> {
     } else {
       bufferEntries = await pMap(entries, async ([id, v]) => [
         id,
-        await this.cfg.hooks!.mapValueToBuffer(v),
+        await this.cfg.hooks!.mapValueToBuffer!(v),
       ])
     }
 
@@ -84,6 +112,10 @@ export class CommonKeyValueDao<T> {
     await this.cfg.db.deleteByIds(this.cfg.table, ids)
   }
 
+  async deleteById(id: string): Promise<void> {
+    await this.cfg.db.deleteByIds(this.cfg.table, [id])
+  }
+
   streamIds(limit?: number): ReadableTyped<string> {
     return this.cfg.db.streamIds(this.cfg.table, limit)
   }
@@ -96,7 +128,7 @@ export class CommonKeyValueDao<T> {
     // todo: consider it when readableMap supports `errorMode: SUPPRESS`
     // readableMap(this.cfg.db.streamValues(this.cfg.table, limit), async buf => await this.cfg.hooks!.mapBufferToValue(buf))
     return this.cfg.db.streamValues(this.cfg.table, limit).pipe(
-      transformMap(async buf => await this.cfg.hooks!.mapBufferToValue(buf), {
+      transformMap(async buf => await this.cfg.hooks!.mapBufferToValue!(buf), {
         errorMode: ErrorMode.SUPPRESS, // cause .pipe cannot propagate errors
       }),
     )
@@ -108,7 +140,7 @@ export class CommonKeyValueDao<T> {
     }
 
     return this.cfg.db.streamEntries(this.cfg.table, limit).pipe(
-      transformMap(async ([id, buf]) => [id, await this.cfg.hooks!.mapBufferToValue(buf)], {
+      transformMap(async ([id, buf]) => [id, await this.cfg.hooks!.mapBufferToValue!(buf)], {
         errorMode: ErrorMode.SUPPRESS, // cause .pipe cannot propagate errors
       }),
     )

package/src/testing/dbTest.ts

@@ -35,6 +35,12 @@ export interface CommonDBImplementationFeatures {
 
   bufferSupport?: boolean
   nullValues?: boolean
+
+  /**
+   * Set false for SQL (relational) databases,
+   * they will return `null` for all missing properties.
+   */
+  documentDB?: boolean
 }
 
 /**
@@ -78,6 +84,7 @@ export function runCommonDBTest(
     strongConsistency = true,
     bufferSupport = true,
     nullValues = true,
+    documentDB = true,
   } = features
 
   // const {
@@ -151,21 +158,23 @@ export function runCommonDBTest(
     })
   }
 
-  test('undefined values should not be saved/loaded', async () => {
-    const item3 = {
-      ...createTestItemDBM(3),
-      k2: undefined,
-    }
-    deepFreeze(item3)
-    const expected = { ...item3 }
-    delete expected.k2
-
-    await db.saveBatch(TEST_TABLE, [item3])
-    const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
-    expectMatch([expected], [item3Loaded], quirks)
-    expect(item3Loaded.k2).toBe(undefined)
-    expect(Object.keys(item3Loaded)).not.toContain('k2')
-  })
+  if (documentDB) {
+    test('undefined values should not be saved/loaded', async () => {
+      const item3 = {
+        ...createTestItemDBM(3),
+        k2: undefined,
+      }
+      deepFreeze(item3)
+      const expected = { ...item3 }
+      delete expected.k2
+
+      await db.saveBatch(TEST_TABLE, [item3])
+      const item3Loaded = (await db.getByIds<TestItemDBM>(TEST_TABLE, [item3.id]))[0]!
+      expectMatch([expected], [item3Loaded], quirks)
+      expect(item3Loaded.k2).toBe(undefined)
+      expect(Object.keys(item3Loaded)).not.toContain('k2')
+    })
+  }
 
   test('saveBatch test items', async () => {
     await db.saveBatch(TEST_TABLE, items)

package/src/testing/keyValueDBTest.ts

@@ -25,6 +25,10 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
     expect(results).toEqual([])
   })
 
+  test('count should be 0', async () => {
+    expect(await db.count(TEST_TABLE)).toBe(0)
+  })
+
   test('saveBatch, then getByIds', async () => {
     await db.saveBatch(TEST_TABLE, testEntries)
 
@@ -33,6 +37,10 @@ export function runCommonKeyValueDBTest(db: CommonKeyValueDB): void {
     expect(entries).toEqual(testEntries)
   })
 
+  test('count should be 3', async () => {
+    expect(await db.count(TEST_TABLE)).toBe(3)
+  })
+
   test('streamIds', async () => {
     const ids = await readableToArray(db.streamIds(TEST_TABLE))
     ids.sort()