@naturalcycles/db-lib 10.42.2 → 10.44.0

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

@@ -173,8 +173,8 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * Validates (unless `skipValidation=true` passed).
      */
     private validateAndConvert;
-    getTableSchema(): Promise<JsonSchema<any, DBM>>;
-    createTable(schema: JsonSchema<any, DBM>, opt?: CommonDaoCreateOptions): Promise<void>;
+    getTableSchema(): Promise<JsonSchema<DBM>>;
+    createTable(schema: JsonSchema<DBM>, opt?: CommonDaoCreateOptions): Promise<void>;
     /**
      * Proxy to this.cfg.db.ping
      */
@@ -201,7 +201,7 @@ export declare class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity
      *   return dbm
      * }
      */
-    static decompressLegacyRow<T extends ObjectWithId>(row: T): Promise<T>;
+    static decompressLegacyRow<T extends ObjectWithId>(this: void, row: T): Promise<T>;
     /**
      * Temporary helper to migrate from the old `data` compressed property to the new `__compressed` property.
      * Use as your `beforeDBMToBM` hook during the migration period.

package/dist/commondao/common.dao.js

@@ -89,7 +89,7 @@ export class CommonDao {
         if (!id)
             return null;
         const [row] = await this.loadByIds([id], opt);
-        return await (this.anyToDBM(row, opt) || null);
+        return await this.anyToDBM(row, opt);
     }
     async getByIds(ids, opt = {}) {
         const dbms = await this.loadByIds(ids, opt);

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

@@ -89,7 +89,7 @@ export interface CommonDaoCfg<BM extends BaseDBEntity, DBM extends BaseDBEntity
      * It removes the knowledge from CommonDao about the validation library used
      * and abstracts it away.
      */
-    validateBM?: ValidationFunction<BM, BM, any>;
+    validateBM?: ValidationFunction<BM, any>;
     /**
      * Used by e.g Datastore.
      */

package/dist/kv/commonSyncKeyValueDB.d.ts

@@ -0,0 +1,56 @@
+import type { Pipeline } from '@naturalcycles/nodejs-lib/stream';
+import type { CommonDBCreateOptions } from '../db.model.js';
+import type { CommonKeyValueDBSaveBatchOptions, CommonKeyValueDBSupport, IncrementTuple, KeyValueDBTuple } from './commonKeyValueDB.js';
+/**
+ * Common interface for Synchronous Key-Value database implementations.
+ * Same as CommonKeyValueDB, but with a sync implementation,
+ * modeled after e.g SQLite in Node.js, which is designed to be sync.
+ *
+ * Methods use `Sync` postfix to allow one implementation to support
+ * both async and sync CommonKeyValueDB interfaces.
+ *
+ * @experimental
+ */
+export interface CommonSyncKeyValueDB {
+    /**
+     * Manifest of supported features.
+     */
+    support: CommonKeyValueDBSupport;
+    /**
+     * Check that DB connection is working properly.
+     */
+    pingSync: () => void;
+    /**
+     * Will do like `create table ...` for mysql.
+     * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
+     */
+    createTableSync: (table: string, opt?: CommonDBCreateOptions) => void;
+    /**
+     * Returns an array of tuples [key, value]. Not found values are not returned (no error is thrown).
+     *
+     * Currently it is NOT required to maintain the same order as input `ids`.
+     */
+    getByIdsSync: (table: string, ids: string[]) => KeyValueDBTuple[];
+    deleteByIdsSync: (table: string, ids: string[]) => void;
+    saveBatchSync: (table: string, entries: KeyValueDBTuple[], opt?: CommonKeyValueDBSaveBatchOptions) => void;
+    streamIds: (table: string, limit?: number) => Pipeline<string>;
+    streamValues: (table: string, limit?: number) => Pipeline<Buffer>;
+    streamEntries: (table: string, limit?: number) => Pipeline<KeyValueDBTuple>;
+    countSync: (table: string) => number;
+    /**
+     * Perform a batch of Increment operations.
+     * Given entries array, increment each key of it (1st index of the tuple) by the given amount (2nd index of the tuple).
+     *
+     * Example:
+     * [
+     *   ['key1', 2],
+     *   ['key2', 3],
+     * ]
+     * would increment `key1` by 2, and `key2` by 3.
+     *
+     * Returns the entries array with tuples of the same structure, with updated numbers.
+     *
+     * @experimental
+     */
+    incrementBatchSync: (table: string, entries: IncrementTuple[]) => IncrementTuple[];
+}

package/dist/kv/commonSyncKeyValueDB.js

@@ -0,0 +1 @@
+export {};

package/dist/kv/index.d.ts

@@ -1,3 +1,4 @@
 export * from './commonKeyValueDao.js';
 export * from './commonKeyValueDaoMemoCache.js';
 export * from './commonKeyValueDB.js';
+export * from './commonSyncKeyValueDB.js';

package/dist/kv/index.js

@@ -1,3 +1,4 @@
 export * from './commonKeyValueDao.js';
 export * from './commonKeyValueDaoMemoCache.js';
 export * from './commonKeyValueDB.js';
+export * from './commonSyncKeyValueDB.js';

package/dist/testing/test.model.d.ts

@@ -19,7 +19,7 @@ export interface TestItemTM {
     even?: boolean;
 }
 export declare const testItemTMSchema: any;
-export declare const testItemBMSchema: JsonSchemaObjectBuilder<TestItemBM, TestItemBM, false>;
+export declare const testItemBMSchema: JsonSchemaObjectBuilder<TestItemBM, false>;
 export declare function createTestItemDBM(num?: number): TestItemDBM;
 export declare function createTestItemBM(num?: number): TestItemBM;
 export declare function createTestItemsDBM(count?: number): TestItemDBM[];

package/dist/validation/index.d.ts

@@ -1,5 +1,5 @@
 import type { CommonDBOptions } from '../db.model.js';
-export declare const commonDBOptionsSchema: () => JsonSchemaObjectBuilder<CommonDBOptions, CommonDBOptions>;
+export declare const commonDBOptionsSchema: () => JsonSchemaObjectBuilder<CommonDBOptions, false>;
 export declare const commonDBSaveOptionsSchema: <ROW extends ObjectWithId>() => any;
 export declare const dbQueryFilterOperatorSchema: any;
 export declare const dbQueryFilterSchema: <ROW extends ObjectWithId>() => any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/db-lib",
   "type": "module",
-  "version": "10.42.2",
+  "version": "10.44.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@naturalcycles/nodejs-lib": "^15"

package/readme.md

@@ -303,14 +303,6 @@ Passing empty array will actually return an array of empty objects (documented e
 .select(['id']) //=> [ { id: 'id1' }, { id: 'id2' }, ... ]
 ```
 
-# Exports
-
-- `/` root
-- `/adapter/file`
-- `/adapter/cachedb`
-- `/testing`
-  - dbTest
-  - daoTest
-  - Test models, utils, etc
-- `/validation`
-  - Joi validation schemas for DBQuery, CommonDBOptions, CommonSchema, etc
+## chore-counter
+
+1

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

@@ -109,7 +109,7 @@ export interface CommonDaoCfg<
    * It removes the knowledge from CommonDao about the validation library used
    * and abstracts it away.
    */
-  validateBM?: ValidationFunction<BM, BM, any>
+  validateBM?: ValidationFunction<BM, any>
 
   /**
    * Used by e.g Datastore.

package/src/commondao/common.dao.ts

@@ -137,7 +137,7 @@ export class CommonDao<
   async getByIdAsDBM(id?: ID | null, opt: CommonDaoReadOptions = {}): Promise<DBM | null> {
     if (!id) return null
     const [row] = await this.loadByIds([id], opt)
-    return await (this.anyToDBM(row, opt) || null)
+    return await this.anyToDBM(row, opt)
   }
 
   async getByIds(ids: ID[], opt: CommonDaoReadOptions = {}): Promise<BM[]> {
@@ -926,11 +926,11 @@ export class CommonDao<
     return convertedValue
   }
 
-  async getTableSchema(): Promise<JsonSchema<any, DBM>> {
+  async getTableSchema(): Promise<JsonSchema<DBM>> {
     return await this.cfg.db.getTableSchema<DBM>(this.cfg.table)
   }
 
-  async createTable(schema: JsonSchema<any, DBM>, opt?: CommonDaoCreateOptions): Promise<void> {
+  async createTable(schema: JsonSchema<DBM>, opt?: CommonDaoCreateOptions): Promise<void> {
     this.requireWriteAccess()
     await this.cfg.db.createTable(this.cfg.table, schema, opt)
   }
@@ -989,7 +989,7 @@ export class CommonDao<
    *   return dbm
    * }
    */
-  static async decompressLegacyRow<T extends ObjectWithId>(row: T): Promise<T> {
+  static async decompressLegacyRow<T extends ObjectWithId>(this: void, row: T): Promise<T> {
     // Check both __compressed (current) and data (legacy) for backward compatibility
     const compressed = (row as any).__compressed ?? (row as any).data
     if (!Buffer.isBuffer(compressed)) return row

package/src/kv/commonSyncKeyValueDB.ts

@@ -0,0 +1,74 @@
+import type { Pipeline } from '@naturalcycles/nodejs-lib/stream'
+import type { CommonDBCreateOptions } from '../db.model.js'
+import type {
+  CommonKeyValueDBSaveBatchOptions,
+  CommonKeyValueDBSupport,
+  IncrementTuple,
+  KeyValueDBTuple,
+} from './commonKeyValueDB.js'
+
+/**
+ * Common interface for Synchronous Key-Value database implementations.
+ * Same as CommonKeyValueDB, but with a sync implementation,
+ * modeled after e.g SQLite in Node.js, which is designed to be sync.
+ *
+ * Methods use `Sync` postfix to allow one implementation to support
+ * both async and sync CommonKeyValueDB interfaces.
+ *
+ * @experimental
+ */
+export interface CommonSyncKeyValueDB {
+  /**
+   * Manifest of supported features.
+   */
+  support: CommonKeyValueDBSupport
+
+  /**
+   * Check that DB connection is working properly.
+   */
+  pingSync: () => void
+
+  /**
+   * Will do like `create table ...` for mysql.
+   * Caution! dropIfExists defaults to false. If set to true - will actually DROP the table!
+   */
+  createTableSync: (table: string, opt?: CommonDBCreateOptions) => void
+
+  /**
+   * Returns an array of tuples [key, value]. Not found values are not returned (no error is thrown).
+   *
+   * Currently it is NOT required to maintain the same order as input `ids`.
+   */
+  getByIdsSync: (table: string, ids: string[]) => KeyValueDBTuple[]
+
+  deleteByIdsSync: (table: string, ids: string[]) => void
+
+  saveBatchSync: (
+    table: string,
+    entries: KeyValueDBTuple[],
+    opt?: CommonKeyValueDBSaveBatchOptions,
+  ) => void
+
+  streamIds: (table: string, limit?: number) => Pipeline<string>
+  streamValues: (table: string, limit?: number) => Pipeline<Buffer>
+  streamEntries: (table: string, limit?: number) => Pipeline<KeyValueDBTuple>
+
+  countSync: (table: string) => number
+
+  /**
+   * Perform a batch of Increment operations.
+   * Given entries array, increment each key of it (1st index of the tuple) by the given amount (2nd index of the tuple).
+   *
+   * Example:
+   * [
+   *   ['key1', 2],
+   *   ['key2', 3],
+   * ]
+   * would increment `key1` by 2, and `key2` by 3.
+   *
+   * Returns the entries array with tuples of the same structure, with updated numbers.
+   *
+   * @experimental
+   */
+  incrementBatchSync: (table: string, entries: IncrementTuple[]) => IncrementTuple[]
+}

package/src/kv/index.ts

@@ -1,3 +1,4 @@
 export * from './commonKeyValueDao.js'
 export * from './commonKeyValueDaoMemoCache.js'
 export * from './commonKeyValueDB.js'
+export * from './commonSyncKeyValueDB.js'

package/src/testing/test.model.ts

@@ -31,7 +31,7 @@ export const testItemTMSchema = j.object<TestItemTM>({
   even: j.boolean().optional(),
 })
 
-export const testItemBMSchema: JsonSchemaObjectBuilder<TestItemBM, TestItemBM, false> =
+export const testItemBMSchema: JsonSchemaObjectBuilder<TestItemBM, false> =
   j.object.dbEntity<TestItemBM>({
     // todo: figure out how to not copy-paste these 3 fields
     id: j.string(), // todo: not strictly needed here

package/src/validation/index.ts

@@ -11,12 +11,9 @@ import type { DBQueryFilter, DBQueryOrder } from '../query/dbQuery.js'
 const dbTransactionSchema = j.object.any().castAs<DBTransaction>()
 
 // Schema that accepts any value (string, number, boolean, object, array, null)
-const anyValueSchema = new JsonSchemaAnyBuilder<any, any, false>({})
+const anyValueSchema = new JsonSchemaAnyBuilder<any, false>({})
 
-export const commonDBOptionsSchema = (): JsonSchemaObjectBuilder<
-  CommonDBOptions,
-  CommonDBOptions
-> =>
+export const commonDBOptionsSchema = (): JsonSchemaObjectBuilder<CommonDBOptions, false> =>
   j.object<CommonDBOptions>({
     tx: dbTransactionSchema.optional(),
   })