@vlasky/zongji 0.5.9 → 0.6.1

package/lib/sequence/binlog.js

@@ -1,56 +1,159 @@
-const Util = require('util');
-const { EofPacket, ErrorPacket, ComBinlog, initBinlogPacketClass } = require('../packet');
-const Sequence = require('@vlasky/mysql/lib/protocol/sequences').Sequence;
+import { EventEmitter } from 'events';
+import { initBinlogPacketClass } from '../packet/index.js';
+import { Parser } from '../reader.js';
 
-module.exports = function(zongji) {
-  const BinlogPacket = initBinlogPacketClass(zongji);
+const BINLOG_DUMP_COMMAND = 0x12;
+
+class Command extends EventEmitter {
+  constructor() {
+    super();
+    this.next = null;
+  }
+
+  execute(packet, connection) {
+    if (!this.next) {
+      // @ts-ignore - start is defined in subclass
+      this.next = this.start;
+      connection._resetSequenceId();
+    }
+    if (packet && packet.isError && packet.isError()) {
+      const err = packet.asError(connection.clientEncoding);
+      // @ts-ignore - onResult is an optional callback property
+      if (this.onResult) {
+        // @ts-ignore
+        this.onResult(err);
+        this.emit('end');
+      } else {
+        this.emit('error', err);
+        this.emit('end');
+      }
+      return true;
+    }
+    this.next = this.next(packet, connection);
+    if (this.next) {
+      return false;
+    }
+    this.emit('end');
+    return true;
+  }
+}
+
+class SimplePacket {
+  constructor(length) {
+    this.buffer = Buffer.allocUnsafe(length);
+    this.offset = 4;
+  }
+
+  length() {
+    return this.buffer.length;
+  }
+
+  writeInt8(value) {
+    this.buffer.writeUInt8(value, this.offset);
+    this.offset += 1;
+  }
 
-  function Binlog(callback) {
-    Sequence.call(this, callback);
+  writeInt16(value) {
+    this.buffer.writeUInt16LE(value, this.offset);
+    this.offset += 2;
   }
 
-  Util.inherits(Binlog, Sequence);
+  writeInt24(value) {
+    this.buffer.writeUIntLE(value, this.offset, 3);
+    this.offset += 3;
+  }
+
+  writeInt32(value) {
+    this.buffer.writeUInt32LE(value, this.offset);
+    this.offset += 4;
+  }
+
+  writeNullTerminatedString(value, encoding) {
+    const buf = Buffer.from(value, encoding);
+    buf.copy(this.buffer, this.offset);
+    this.offset += buf.length;
+    this.writeInt8(0);
+  }
+
+  writeHeader(sequenceId) {
+    const offset = this.offset;
+    this.offset = 0;
+    this.writeInt24(this.buffer.length - 4);
+    this.writeInt8(sequenceId);
+    this.offset = offset;
+  }
+}
 
-  Binlog.prototype.start = function() {
-    // options include: position / nonBlock / serverId / filename
-    let options = zongji.get([
-      'serverId', 'position', 'filename', 'nonBlock',
-    ]);
-    this.emit('packet', new ComBinlog(options));
-  };
+export default function initBinlogClass(zongji) {
+  const BinlogPacket = initBinlogPacketClass(zongji);
 
-  Binlog.prototype.determinePacket = function(firstByte) {
-    switch (firstByte) {
-    case 0xfe:
-      return EofPacket;
-    case 0xff:
-      return ErrorPacket;
-    default:
-      return BinlogPacket;
+  class Binlog extends Command {
+    constructor(callback) {
+      super();
+      this._callback = callback;
     }
-  };
 
-  Binlog.prototype['OkPacket'] = function() {
-    console.log('Received one OkPacket ...');
-  };
+    start(packet, connection) {
+      const options = zongji.get([
+        'serverId', 'position', 'filename', 'nonBlock',
+      ]);
+      const binlogPos = options.position || 4;
+      const serverId = options.serverId || 1;
+      const flags = options.nonBlock ? 1 : 0;
+      const filename = options.filename || '';
 
-  Binlog.prototype['BinlogPacket'] = function(packet) {
-    if (this._callback) {
+      const length = 16 + Buffer.byteLength(filename, 'utf8');
+      const outPacket = new SimplePacket(length);
+      outPacket.writeInt8(BINLOG_DUMP_COMMAND);
+      outPacket.writeInt32(binlogPos);
+      outPacket.writeInt16(flags);
+      outPacket.writeInt32(serverId);
+      outPacket.writeNullTerminatedString(filename, 'utf8');
+      connection.writePacket(outPacket);
+      return Binlog.prototype.binlogData;
+    }
 
-      // Check event filtering
-      if (zongji._skipEvent(packet.eventName.toLowerCase())) {
-        return this._callback.call(this);
+    binlogData(packet, connection) {
+      if (packet.isEOF()) {
+        this.emit('eof');
+        return null;
       }
 
-      let event, error;
-      try {
-        event = packet.getEvent();
-      } catch (err) {
-        error = err;
+      if (packet.isError()) {
+        const err = packet.asError(connection.clientEncoding);
+        if (this._callback) {
+          this._callback.call(this, err);
+        } else {
+          this.emit('error', err);
+        }
+        return null;
       }
-      this._callback.call(this, error, event);
+
+      const parser = new Parser(packet);
+      const binlogPacket = new BinlogPacket();
+      binlogPacket.parse(parser);
+
+      if (this._callback) {
+        const eventName = binlogPacket.eventName
+          ? binlogPacket.eventName.toLowerCase()
+          : 'unknown';
+        if (zongji._skipEvent(eventName)) {
+          return Binlog.prototype.binlogData;
+        }
+
+        let event;
+        let error;
+        try {
+          event = binlogPacket.getEvent();
+        } catch (err) {
+          error = err;
+        }
+        this._callback.call(this, error, event);
+      }
+
+      return Binlog.prototype.binlogData;
     }
-  };
+  }
 
   return Binlog;
 };

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "@vlasky/zongji",
-  "version": "0.5.9",
-  "description": "A MySQL 8.0-compatible fork of ZongJi - a MySQL binlog listener for Node.js.",
+  "version": "0.6.1",
+  "description": "MySQL binlog-based change data capture (CDC) for Node.js",
+  "type": "module",
   "main": "index.js",
+  "types": "index.d.ts",
   "directories": {
     "test": "test"
   },
   "scripts": {
-    "test": "tap --bail --no-coverage --jobs=1 test/*.js",
-    "lint": "eslint ."
+    "pretest": "bash scripts/start-mysql.sh",
+    "test": "tap --bail --disable-coverage --jobs=1 test/*.js",
+    "lint": "eslint .",
+    "checkjs": "tsc --project jsconfig.json"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/vlasky/zongji"
+    "url": "git+https://github.com/vlasky/zongji.git"
   },
   "keywords": [
     "mysql",
@@ -30,15 +34,16 @@
   ],
   "license": "MIT",
   "engines": {
-    "node": ">= 8.0"
+    "node": ">= 18.0"
   },
   "devDependencies": {
-    "eslint": "6.8.0",
-    "tap": "14.10.7"
+    "@eslint/js": "^9.39.2",
+    "eslint": "^9.39.2",
+    "tap": "^21.5.0"
   },
   "dependencies": {
-    "big-integer": "1.6.51",
-    "iconv-lite": "0.6.3",
-    "@vlasky/mysql": "^2.18.6"
+    "big-integer": "1.6.52",
+    "iconv-lite": "0.7.2",
+    "mysql2": "^3.17.1"
   }
 }

package/scripts/start-mysql.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+# Start MySQL Docker containers for testing
+# Skips MySQL 5.7 on ARM64 (Apple Silicon) as no image is available
+
+if [ "$(uname -m)" = "arm64" ]; then
+  SERVICES="mysql80 mysql84"
+else
+  SERVICES="mysql57 mysql80 mysql84"
+fi
+
+docker-compose up -d $SERVICES
+
+# Wait for MySQL to be ready
+for service in $SERVICES; do
+  container="zongji-${service}-1"
+  echo -n "Waiting for ${service}..."
+  for i in $(seq 1 30); do
+    if docker exec "$container" mysqladmin ping -u root -psecret --silent 2>/dev/null; then
+      echo " ready"
+      break
+    fi
+    if [ "$i" -eq 30 ]; then
+      echo " timed out"
+      exit 1
+    fi
+    sleep 2
+  done
+done

package/.eslintrc

@@ -1,19 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "es2020": true
-  },
-  "extends": "eslint:recommended",
-  "rules": {
-    "comma-dangle": ["warn", "only-multiline"],
-    "eol-last": ["error"],
-    "keyword-spacing": ["error", { "before": true } ],
-    "no-console": "off",
-    "no-trailing-spaces": ["error", { "skipBlankLines": true }],
-    "no-unused-vars": "warn",
-    "no-var": "warn",
-    "quotes": ["warn", "single", "avoid-escape"],
-    "semi": ["error", "always"],
-    "space-before-blocks": "error"
-  }
-}