@solashi/go-mysql-binlog-node 0.0.1

package/README.md

@@ -0,0 +1,66 @@
+# @solashi/go-mysql-binlog-node
+
+A library wrapping the [go-mysql](https://github.com/go-mysql-org/go-mysql) package, providing a MySQL client connector and binlog parsing implementation.
+
+> This project is forked from [go-mysql-js](https://github.com/go-mysql-org/go-mysql-js)
+
+## Installation
+
+```bash
+npm i --save @solashi/go-mysql-binlog-node
+```
+
+* Enable MySQL binlog in `my.cnf`, restart MySQL server after making the changes.
+  > binlog checksum is enabled by default. @solashi/go-mysql-binlog-node can work with it, but it doesn't really verify it.
+
+  ```
+  # Must be unique integer from 1-2^32
+  server-id        = 1
+  # Row format required
+  binlog_format    = row
+  # Directory must exist. This path works for Linux. Other OS may require
+  #   different path.
+  log_bin          = /var/log/mysql/mysql-bin.log
+
+  binlog_do_db     = employees   # Optional, limit which databases to log
+  expire_logs_days = 10          # Optional, purge old logs
+  max_binlog_size  = 100M        # Optional, limit log size
+  ```
+
+* Create an account with replication privileges, e.g. given privileges to account `root` (or any account that you use to read binary logs)
+
+  ```sql
+  GRANT REPLICATION SLAVE, REPLICATION CLIENT, SELECT ON *.* TO 'root'@'localhost'
+  ```
+
+## Example
+
+```js
+import MysqlBinlog from '@solashi/go-mysql-binlog-node';
+
+async function main() {
+    let syncer = await MysqlBinlog.create({
+        hostname: "localhost",
+        port: 3306,
+        username: "root",
+        password: "mypassword",
+        tableRegexes: ['Users'],
+    });
+    syncer.on('event', (event) => {
+        console.log('got row event', event);
+    });
+    syncer.on('error', (err) => {
+        console.error('got error', err);
+    });
+
+    process.on('SIGINT', function() {
+        console.log("Caught interrupt signal");
+        syncer.close();
+    });
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});
+```

package/dist/binding.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from 'events';
+export interface BinlogPosition {
+    name: string;
+    position: number;
+}
+export interface Config {
+    hostname: string;
+    port: number;
+    username: string;
+    password: string;
+    tableRegexes: string[];
+    binlogPosition?: BinlogPosition;
+}
+export interface BinlogEvent {
+    binlogPosition: {
+        name: string;
+        position: number;
+    };
+    table: {
+        schema: string;
+        name: string;
+    };
+    insert?: Record<string, any>[];
+    update?: {
+        old: Record<string, any>;
+        new: Record<string, any>;
+    }[];
+    delete?: Record<string, any>[];
+}
+export declare class ErrorWithBinLogPosition extends Error {
+    readonly binlogPosition: BinlogPosition;
+    constructor(message: string, binlogPosition: BinlogPosition);
+}
+declare class MysqlBinlog extends EventEmitter {
+    private _process;
+    private _readline;
+    private constructor();
+    private send;
+    static create(config: Config): Promise<MysqlBinlog>;
+    close(): Promise<void>;
+    on(name: 'event', listener: (event: BinlogEvent) => void): this;
+    on(name: 'error', listener: (err: Error) => void): this;
+    on(name: 'close', listener: () => void): this;
+    on(name: 'beforeClose', listener: () => void): this;
+}
+export default MysqlBinlog;

package/dist/binding.js

@@ -0,0 +1,152 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorWithBinLogPosition = void 0;
+const events_1 = require("events");
+const debug_1 = require("debug");
+const child_process_1 = require("child_process");
+const readline = require("readline");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const debugChannel = (0, debug_1.debug)('mysql_binlog');
+class ErrorWithBinLogPosition extends Error {
+    constructor(message, binlogPosition) {
+        super(message);
+        this.name = this.constructor.name;
+        this.binlogPosition = binlogPosition;
+    }
+}
+exports.ErrorWithBinLogPosition = ErrorWithBinLogPosition;
+function _discoverGoBinary() {
+    let suffix = '';
+    if (os.platform() === 'win32') {
+        suffix = '.exe';
+    }
+    const filename = path.join(__dirname, '..', 'prebuilds', `${os.platform()}-${os.arch()}${suffix}`);
+    if (!fs.existsSync(filename)) {
+        throw new Error('Could not find pre-compiled Go binary. Either your platform is unsupported or you need to compile the binaries');
+    }
+    return filename;
+}
+class MysqlBinlog extends events_1.EventEmitter {
+    constructor(config, process) {
+        super();
+        this._process = process;
+        this._readline = readline.createInterface({
+            input: this._process.stdout,
+            crlfDelay: Infinity,
+        });
+        this._readline.on('line', (line) => {
+            let msg;
+            try {
+                msg = JSON.parse(line);
+                if (typeof msg !== 'object') {
+                    throw new Error();
+                }
+            }
+            catch (err) {
+                debugChannel('received unexpected message on stdout: %s', line);
+                this.emit('error', new Error('received unexpected message'));
+                return;
+            }
+            switch (msg.type) {
+                case 'connect_ok':
+                    this.emit('_connect_ok');
+                    break;
+                case 'connect_error':
+                    this.emit('_connect_err', new Error(msg.error));
+                    break;
+                case 'binlog_change':
+                    this.emit('event', msg.event);
+                    break;
+                case 'log':
+                    debugChannel(msg.message.trimEnd());
+                    break;
+                case 'error':
+                    console.log(msg);
+                    if (msg.binlogPosition) {
+                        this.emit('error', new ErrorWithBinLogPosition(msg.error, msg.binlogPosition));
+                    }
+                    else {
+                        this.emit('error', new Error(msg.error));
+                    }
+                    break;
+                default:
+                    debugChannel('received unexpected message on stdout: %o', msg);
+                    this.emit('error', new Error('received unexpected message'));
+                    break;
+            }
+        });
+        this._process.stderr.on('data', (chunk) => {
+            debugChannel('received unexpected data on stderr: %s', chunk);
+            this.emit('error', new Error('received unexpected data on stderr'));
+        });
+        this._process.on('close', () => {
+            this.emit('close');
+        });
+        this._process.on('error', (err) => {
+            debugChannel('received unexpected error: %s', err);
+            this.emit('error', err);
+        });
+        this.send({
+            type: 'connect',
+            config,
+        });
+    }
+    send(message) {
+        this._process.stdin.write(JSON.stringify(message) + '\n');
+    }
+    static create(config) {
+        return new Promise((resolve, reject) => {
+            const process = (0, child_process_1.spawn)(_discoverGoBinary(), {
+                stdio: 'pipe',
+            });
+            process.on('error', (err) => {
+                reject(err);
+            });
+            process.once('spawn', () => {
+                process.removeAllListeners('error');
+                const obj = new MysqlBinlog(config, process);
+                obj.once('_connect_ok', () => {
+                    resolve(obj);
+                });
+                obj.once('_connect_err', (err) => {
+                    obj.close();
+                    reject(err);
+                });
+            });
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._process.exitCode !== null) {
+                // do not try to kill the process multiple times
+                return;
+            }
+            this.emit('beforeClose');
+            this._readline.close();
+            this._process.kill();
+            return new Promise((resolve, reject) => {
+                this._process.once('error', (err) => {
+                    reject(err);
+                });
+                this._process.once('close', () => {
+                    resolve(undefined);
+                });
+            });
+        });
+    }
+    on(eventName, listener) {
+        return super.on(eventName, listener);
+    }
+}
+exports.default = MysqlBinlog;

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@solashi/go-mysql-binlog-node",
+    "version": "0.0.1",
+    "description": "A Node.js MySQL binlog listener based on go-mysql",
+    "main": "dist/binding.js",
+    "types": "dist/binding.d.ts",
+    "scripts": {
+        "test": "node ./test/test_binding.js",
+        "build": "npm run build:golang && npm run build:js",
+        "build:js": "tsc",
+        "build:golang": "node scripts/build_golang.js",
+        "postinstall": "node scripts/postinstall.js"
+    },
+    "keywords": [
+        "mysql",
+        "binlog"
+    ],
+    "dependencies": {
+        "debug": "^4.4.0"
+    },
+    "devDependencies": {
+        "@types/debug": "^4.1.12",
+        "@types/node": "^22.13.4",
+        "typescript": "^5.7.3"
+    },
+    "files": [
+        "dist/*",
+        "prebuilds/*",
+        "scripts/postinstall.js"
+    ],
+    "author": "Pham Van Cong",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/congpv93/mysql-binlog-node"
+    },
+    "bugs": {
+        "url": "https://github.com/congpv93/mysql-binlog-node"
+    },
+    "homepage": "https://github.com/congpv93/mysql-binlog-node"
+}

package/scripts/postinstall.js

@@ -0,0 +1,38 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+function nativeGoBinaryName() {
+    let suffix = '';
+    if (os.platform() === 'win32') {
+        suffix = '.exe';
+    }
+    return `${os.platform()}-${os.arch()}${suffix}`;
+}
+
+const PREBUILDS_PATH = path.join(__dirname, '..', 'prebuilds');
+const nativeBinaryFilename = nativeGoBinaryName();
+
+if (!fs.existsSync(PREBUILDS_PATH)) {
+    console.error('WARNING: directory containing precompiled Go binaries does not exist. Please run "npm run build" first.');
+    return;
+}
+
+let nativeBinaryFound = false;
+for (const entry of fs.readdirSync(PREBUILDS_PATH, { withFileTypes: true })) {
+    if (!entry.isFile()) {
+        continue;
+    }
+
+    if (entry.name !== nativeBinaryFilename) {
+        fs.unlinkSync(path.join(PREBUILDS_PATH, entry.name));
+    } else {
+        // ensure the binary is executable
+        fs.chmodSync(path.join(PREBUILDS_PATH, entry.name), 0o755);
+        nativeBinaryFound = true;
+    }
+}
+
+if (!nativeBinaryFound) {
+    console.error(`WARNING: could not find the precompiled Go binary for your platform (${nativeBinaryFilename})!`);
+}