@naturalcycles/mysql-lib 3.16.0 → 3.16.1

package/dist/mysqlKeyValueDB.d.ts

@@ -1,5 +1,6 @@
-import { CommonDBCreateOptions, CommonKeyValueDB, KeyValueDBTuple } from '@naturalcycles/db-lib';
-import { StringMap } from '@naturalcycles/js-lib';
+import { CommonDBCreateOptions, CommonKeyValueDB } from '@naturalcycles/db-lib';
+import { IncrementTuple } from '@naturalcycles/db-lib/dist/kv/commonKeyValueDB';
+import { KeyValueTuple } from '@naturalcycles/js-lib';
 import { ReadableTyped } from '@naturalcycles/nodejs-lib';
 import { MysqlDB, MysqlDBCfg } from './mysql.db';
 export declare class MySQLKeyValueDB implements CommonKeyValueDB {
@@ -13,19 +14,19 @@ export declare class MySQLKeyValueDB implements CommonKeyValueDB {
     ping(): Promise<void>;
     close(): Promise<void>;
     createTable(table: string, opt?: CommonDBCreateOptions): Promise<void>;
-    getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]>;
+    getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]>;
     /**
      * Use with caution!
      */
     dropTable(table: string): Promise<void>;
     deleteByIds(table: string, ids: string[]): Promise<void>;
-    saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void>;
+    saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): Promise<void>;
     streamIds(table: string, limit?: number): ReadableTyped<string>;
-    streamValues(table: string, limit?: number): ReadableTyped<Buffer>;
-    streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple>;
+    streamValues<V>(table: string, limit?: number): ReadableTyped<V>;
+    streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>>;
     beginTransaction(): Promise<void>;
     endTransaction(): Promise<void>;
     count(table: string): Promise<number>;
     increment(_table: string, _id: string, _by?: number): Promise<number>;
-    incrementBatch(_table: string, _incrementMap: StringMap<number>): Promise<StringMap<number>>;
+    incrementBatch(_table: string, _entries: IncrementTuple[]): Promise<IncrementTuple[]>;
 }

package/dist/mysqlKeyValueDB.js

@@ -104,7 +104,7 @@ class MySQLKeyValueDB {
     async increment(_table, _id, _by) {
         throw new js_lib_1.AppError('MySQLKeyValueDB.increment() is not implemented');
     }
-    async incrementBatch(_table, _incrementMap) {
+    async incrementBatch(_table, _entries) {
         throw new js_lib_1.AppError('MySQLKeyValueDB.incrementBatch() is not implemented');
     }
 }

package/package.json

@@ -41,7 +41,7 @@
   "engines": {
     "node": ">=20.13.0"
   },
-  "version": "3.16.0",
+  "version": "3.16.1",
   "description": "MySQL client implementing CommonDB interface",
   "keywords": [
     "mysql",

package/src/mysqlKeyValueDB.ts

@@ -2,16 +2,16 @@ import {
   CommonDBCreateOptions,
   CommonKeyValueDB,
   commonKeyValueDBFullSupport,
-  KeyValueDBTuple,
 } from '@naturalcycles/db-lib'
-import { AppError, ObjectWithId, pMap, StringMap } from '@naturalcycles/js-lib'
+import { IncrementTuple } from '@naturalcycles/db-lib/dist/kv/commonKeyValueDB'
+import { AppError, KeyValueTuple, ObjectWithId, pMap } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { QueryOptions } from 'mysql'
 import { MysqlDB, MysqlDBCfg } from './mysql.db'
 
-interface KeyValueObject {
+interface KeyValueObject<V> {
   id: string
-  v: Buffer
+  v: V
 }
 
 export class MySQLKeyValueDB implements CommonKeyValueDB {
@@ -45,12 +45,12 @@ export class MySQLKeyValueDB implements CommonKeyValueDB {
     await this.db.runSQL({ sql })
   }
 
-  async getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]> {
+  async getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]> {
     if (!ids.length) return []
 
     const sql = `SELECT id,v FROM ${table} where id in (${ids.map(id => `"${id}"`).join(',')})`
 
-    const rows = await this.db.runSQL<KeyValueObject[]>({ sql })
+    const rows = await this.db.runSQL<KeyValueObject<V>[]>({ sql })
 
     return rows.map(({ id, v }) => [id, v])
   }
@@ -68,7 +68,7 @@ export class MySQLKeyValueDB implements CommonKeyValueDB {
     await this.db.runSQL({ sql })
   }
 
-  async saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void> {
+  async saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): Promise<void> {
     const statements: QueryOptions[] = entries.map(([id, buf]) => {
       return {
         sql: `INSERT INTO ${table} (id, v) VALUES (?, ?)`,
@@ -90,20 +90,20 @@ export class MySQLKeyValueDB implements CommonKeyValueDB {
     return (this.db.pool().query(sql).stream() as ReadableTyped<ObjectWithId>).map(row => row.id)
   }
 
-  streamValues(table: string, limit?: number): ReadableTyped<Buffer> {
+  streamValues<V>(table: string, limit?: number): ReadableTyped<V> {
     let sql = `SELECT v FROM ${table}`
     if (limit) sql += ` LIMIT ${limit}`
     if (this.cfg.logSQL) this.db.cfg.logger.log(`stream: ${sql}`)
 
-    return (this.db.pool().query(sql).stream() as ReadableTyped<{ v: Buffer }>).map(row => row.v)
+    return (this.db.pool().query(sql).stream() as ReadableTyped<{ v: V }>).map(row => row.v)
   }
 
-  streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple> {
+  streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>> {
     let sql = `SELECT id,v FROM ${table}`
     if (limit) sql += ` LIMIT ${limit}`
     if (this.cfg.logSQL) this.db.cfg.logger.log(`stream: ${sql}`)
 
-    return (this.db.pool().query(sql).stream() as ReadableTyped<KeyValueObject>).map(row => [
+    return (this.db.pool().query(sql).stream() as ReadableTyped<KeyValueObject<V>>).map(row => [
       row.id,
       row.v,
     ])
@@ -129,10 +129,7 @@ export class MySQLKeyValueDB implements CommonKeyValueDB {
     throw new AppError('MySQLKeyValueDB.increment() is not implemented')
   }
 
-  async incrementBatch(
-    _table: string,
-    _incrementMap: StringMap<number>,
-  ): Promise<StringMap<number>> {
+  async incrementBatch(_table: string, _entries: IncrementTuple[]): Promise<IncrementTuple[]> {
     throw new AppError('MySQLKeyValueDB.incrementBatch() is not implemented')
   }
 }