@naturalcycles/mysql-lib 3.16.1 → 3.16.3

package/dist/mysql.db.js

@@ -173,8 +173,19 @@ class MysqlDB extends db_lib_1.BaseCommonDB {
         }
         if (this.cfg.logSQL)
             this.cfg.logger.log(`stream: ${sql}`);
-        // return this.streamSQL(sql, opt)
-        return this.pool().query(sql).stream().map(row => (0, js_lib_1._filterUndefinedValues)(row, true));
+        // todo: this is nice, but `mysql` package uses `readable-stream@2` which is not compatible with `node:stream` iterable helpers
+        // return (this.pool().query(sql).stream() as ReadableTyped<ROW>).map(row =>
+        //   _filterUndefinedValues(row, true),
+        // )
+        return this.pool()
+            .query(sql)
+            .stream()
+            .pipe(new node_stream_1.Transform({
+            objectMode: true,
+            transform(row, _encoding, cb) {
+                cb(null, (0, js_lib_1._filterUndefinedValues)(row, true));
+            },
+        }));
     }
     // SAVE
     async saveBatch(table, rowsInput, opt = {}) {

package/dist/mysqlKeyValueDB.d.ts

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

package/dist/mysqlKeyValueDB.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySQLKeyValueDB = void 0;
+const node_stream_1 = require("node:stream");
 const db_lib_1 = require("@naturalcycles/db-lib");
 const js_lib_1 = require("@naturalcycles/js-lib");
 const mysql_db_1 = require("./mysql.db");
@@ -67,7 +68,18 @@ class MySQLKeyValueDB {
             sql += ` LIMIT ${limit}`;
         if (this.cfg.logSQL)
             this.db.cfg.logger.log(`stream: ${sql}`);
-        return this.db.pool().query(sql).stream().map(row => row.id);
+        // todo: this is nice, but `mysql` package uses `readable-stream@2` which is not compatible with `node:stream` iterable helpers
+        // return (this.db.pool().query(sql).stream() as ReadableTyped<ObjectWithId>).map(row => row.id)
+        return this.db
+            .pool()
+            .query(sql)
+            .stream()
+            .pipe(new node_stream_1.Transform({
+            objectMode: true,
+            transform(row, _encoding, cb) {
+                cb(null, row.id);
+            },
+        }));
     }
     streamValues(table, limit) {
         let sql = `SELECT v FROM ${table}`;
@@ -101,9 +113,6 @@ class MySQLKeyValueDB {
         const rows = await this.db.runSQL({ sql });
         return rows[0].cnt;
     }
-    async increment(_table, _id, _by) {
-        throw new js_lib_1.AppError('MySQLKeyValueDB.increment() is not implemented');
-    }
     async incrementBatch(_table, _entries) {
         throw new js_lib_1.AppError('MySQLKeyValueDB.incrementBatch() is not implemented');
     }

package/package.json

@@ -9,17 +9,17 @@
     "lbt": "dev-lib lbt"
   },
   "dependencies": {
-    "@naturalcycles/db-lib": "^9.1.0",
-    "@naturalcycles/js-lib": "^14.47.0",
-    "@naturalcycles/nodejs-lib": "^13.1.0",
-    "@types/mysql": "^2.15.19",
-    "mysql": "^2.17.1"
+    "@naturalcycles/db-lib": "^9",
+    "@naturalcycles/js-lib": "^14",
+    "@naturalcycles/nodejs-lib": "^13",
+    "@types/mysql": "^2",
+    "mysql": "^2"
   },
   "devDependencies": {
-    "@naturalcycles/dev-lib": "^15.18.0",
-    "@types/node": "^22.7.4",
-    "dotenv": "^16.0.0",
-    "jest": "^29.0.0"
+    "@naturalcycles/dev-lib": "^15",
+    "@types/node": "^22",
+    "dotenv": "^16",
+    "jest": "^29"
   },
   "files": [
     "dist",
@@ -39,9 +39,9 @@
     "url": "https://github.com/NaturalCycles/mysql-lib"
   },
   "engines": {
-    "node": ">=20.13.0"
+    "node": ">=22.12.0"
   },
-  "version": "3.16.1",
+  "version": "3.16.3",
   "description": "MySQL client implementing CommonDB interface",
   "keywords": [
     "mysql",

package/src/mysql.db.ts

@@ -1,4 +1,4 @@
-import { Readable } from 'node:stream'
+import { Readable, Transform } from 'node:stream'
 import { promisify } from 'node:util'
 import {
   BaseCommonDB,
@@ -277,10 +277,21 @@ export class MysqlDB extends BaseCommonDB implements CommonDB {
 
     if (this.cfg.logSQL) this.cfg.logger.log(`stream: ${sql}`)
 
-    // return this.streamSQL(sql, opt)
-    return (this.pool().query(sql).stream() as ReadableTyped<ROW>).map(row =>
-      _filterUndefinedValues(row, true),
-    )
+    // todo: this is nice, but `mysql` package uses `readable-stream@2` which is not compatible with `node:stream` iterable helpers
+    // return (this.pool().query(sql).stream() as ReadableTyped<ROW>).map(row =>
+    //   _filterUndefinedValues(row, true),
+    // )
+    return this.pool()
+      .query(sql)
+      .stream()
+      .pipe(
+        new Transform({
+          objectMode: true,
+          transform(row: ROW, _encoding, cb) {
+            cb(null, _filterUndefinedValues(row, true))
+          },
+        }),
+      )
   }
 
   // SAVE

package/src/mysqlKeyValueDB.ts

@@ -1,17 +1,19 @@
+import { Transform } from 'node:stream'
 import {
   CommonDBCreateOptions,
   CommonKeyValueDB,
   commonKeyValueDBFullSupport,
+  KeyValueDBTuple,
 } from '@naturalcycles/db-lib'
 import { IncrementTuple } from '@naturalcycles/db-lib/dist/kv/commonKeyValueDB'
-import { AppError, KeyValueTuple, ObjectWithId, pMap } from '@naturalcycles/js-lib'
+import { AppError, ObjectWithId, pMap } from '@naturalcycles/js-lib'
 import { ReadableTyped } from '@naturalcycles/nodejs-lib'
 import { QueryOptions } from 'mysql'
 import { MysqlDB, MysqlDBCfg } from './mysql.db'
 
-interface KeyValueObject<V> {
+interface KeyValueObject {
   id: string
-  v: V
+  v: Buffer
 }
 
 export class MySQLKeyValueDB implements CommonKeyValueDB {
@@ -45,12 +47,12 @@ export class MySQLKeyValueDB implements CommonKeyValueDB {
     await this.db.runSQL({ sql })
   }
 
-  async getByIds<V>(table: string, ids: string[]): Promise<KeyValueTuple<string, V>[]> {
+  async getByIds(table: string, ids: string[]): Promise<KeyValueDBTuple[]> {
     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<V>[]>({ sql })
+    const rows = await this.db.runSQL<KeyValueObject[]>({ sql })
 
     return rows.map(({ id, v }) => [id, v])
   }
@@ -68,7 +70,7 @@ export class MySQLKeyValueDB implements CommonKeyValueDB {
     await this.db.runSQL({ sql })
   }
 
-  async saveBatch<V>(table: string, entries: KeyValueTuple<string, V>[]): Promise<void> {
+  async saveBatch(table: string, entries: KeyValueDBTuple[]): Promise<void> {
     const statements: QueryOptions[] = entries.map(([id, buf]) => {
       return {
         sql: `INSERT INTO ${table} (id, v) VALUES (?, ?)`,
@@ -87,23 +89,36 @@ export class MySQLKeyValueDB implements CommonKeyValueDB {
     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<ObjectWithId>).map(row => row.id)
-  }
-
-  streamValues<V>(table: string, limit?: number): ReadableTyped<V> {
+    // todo: this is nice, but `mysql` package uses `readable-stream@2` which is not compatible with `node:stream` iterable helpers
+    // return (this.db.pool().query(sql).stream() as ReadableTyped<ObjectWithId>).map(row => row.id)
+    return this.db
+      .pool()
+      .query(sql)
+      .stream()
+      .pipe(
+        new Transform({
+          objectMode: true,
+          transform(row: ObjectWithId, _encoding, cb) {
+            cb(null, row.id)
+          },
+        }),
+      )
+  }
+
+  streamValues(table: string, limit?: number): ReadableTyped<Buffer> {
     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: V }>).map(row => row.v)
+    return (this.db.pool().query(sql).stream() as ReadableTyped<{ v: Buffer }>).map(row => row.v)
   }
 
-  streamEntries<V>(table: string, limit?: number): ReadableTyped<KeyValueTuple<string, V>> {
+  streamEntries(table: string, limit?: number): ReadableTyped<KeyValueDBTuple> {
     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<V>>).map(row => [
+    return (this.db.pool().query(sql).stream() as ReadableTyped<KeyValueObject>).map(row => [
       row.id,
       row.v,
     ])
@@ -125,10 +140,6 @@ export class MySQLKeyValueDB implements CommonKeyValueDB {
     return rows[0]!.cnt
   }
 
-  async increment(_table: string, _id: string, _by?: number): Promise<number> {
-    throw new AppError('MySQLKeyValueDB.increment() is not implemented')
-  }
-
   async incrementBatch(_table: string, _entries: IncrementTuple[]): Promise<IncrementTuple[]> {
     throw new AppError('MySQLKeyValueDB.incrementBatch() is not implemented')
   }