@mango-power/node-kit 0.0.2 → 0.0.3

package/README.md

@@ -2,6 +2,14 @@
 
 Shared node toolkit package for MP services.
 
+## Included modules
+
+- `createLogger`
+- `PGClient`
+- `RedisClient`
+- `RmqService`
+- `EmqxMqttService` / `EMQXMqttService`
+
 ## Build
 
 ```bash
@@ -25,6 +33,6 @@ registry=https://registry.npmjs.org/
 ## Install from other projects
 
 ```bash
-npm i @mango-power/node-kit@^0.0.1
+npm i @mango-power/node-kit@^0.0.3
 ```
 

package/dist/index.d.ts

@@ -1,9 +1,6 @@
-export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
-export interface AppLogger {
-    debug: (...args: unknown[]) => void;
-    info: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-    fatal: (...args: unknown[]) => void;
-}
-export declare function createLogger(service: string): AppLogger;
+export * from "./logger";
+export * from "./pg.service";
+export * from "./redis.service";
+export * from "./rmq.service";
+export * from "./mqtt/mqtt.type";
+export * from "./mqtt/emqx-mqtt.service";

package/dist/index.js

@@ -1,73 +1,22 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = createLogger;
-const LEVEL_WEIGHT = {
-    debug: 10,
-    info: 20,
-    warn: 30,
-    error: 40,
-    fatal: 50,
-};
-function resolveMinLevel() {
-    const raw = (process.env.LOG_LEVEL || "info").toLowerCase();
-    if (raw === "debug" || raw === "info" || raw === "warn" || raw === "error" || raw === "fatal") {
-        return raw;
-    }
-    return "info";
-}
-const minLevel = resolveMinLevel();
-function shouldLog(level) {
-    return LEVEL_WEIGHT[level] >= LEVEL_WEIGHT[minLevel];
-}
-function normalizeErrorRecord(record) {
-    const next = { ...record };
-    const err = next.err ?? next.error;
-    if (err instanceof Error) {
-        next.error = {
-            name: err.name,
-            message: err.message,
-            stack: err.stack,
-        };
-        delete next.err;
-    }
-    return next;
-}
-function prefix(service) {
-    return `[${new Date().toISOString()}] [${service}]`;
-}
-function normalizeArgs(service, args) {
-    if (args.length === 0) {
-        return [prefix(service)];
-    }
-    const [first, ...rest] = args;
-    if (typeof first === "string") {
-        return [`${prefix(service)} ${first}`, ...rest];
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    if (first && typeof first === "object" && !Array.isArray(first)) {
-        return [prefix(service), normalizeErrorRecord(first), ...rest];
-    }
-    return [prefix(service), first, ...rest];
-}
-function write(level, service, ...args) {
-    if (!shouldLog(level))
-        return;
-    const out = normalizeArgs(service, args);
-    if (level === "error" || level === "fatal") {
-        console.error(...out);
-        return;
-    }
-    if (level === "warn") {
-        console.warn(...out);
-        return;
-    }
-    console.log(...out);
-}
-function createLogger(service) {
-    return {
-        debug: (...args) => write("debug", service, ...args),
-        info: (...args) => write("info", service, ...args),
-        warn: (...args) => write("warn", service, ...args),
-        error: (...args) => write("error", service, ...args),
-        fatal: (...args) => write("fatal", service, ...args),
-    };
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./logger"), exports);
+__exportStar(require("./pg.service"), exports);
+__exportStar(require("./redis.service"), exports);
+__exportStar(require("./rmq.service"), exports);
+__exportStar(require("./mqtt/mqtt.type"), exports);
+__exportStar(require("./mqtt/emqx-mqtt.service"), exports);

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+export interface AppLogger {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    fatal: (...args: unknown[]) => void;
+}
+export declare function createLogger(service: string): AppLogger;

package/dist/logger.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const LEVEL_WEIGHT = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    fatal: 50,
+};
+function resolveMinLevel() {
+    const raw = (process.env.LOG_LEVEL || "info").toLowerCase();
+    if (raw === "debug" || raw === "info" || raw === "warn" || raw === "error" || raw === "fatal") {
+        return raw;
+    }
+    return "info";
+}
+const minLevel = resolveMinLevel();
+function shouldLog(level) {
+    return LEVEL_WEIGHT[level] >= LEVEL_WEIGHT[minLevel];
+}
+function normalizeErrorRecord(record) {
+    const next = { ...record };
+    const err = next.err ?? next.error;
+    if (err instanceof Error) {
+        next.error = {
+            name: err.name,
+            message: err.message,
+            stack: err.stack,
+        };
+        delete next.err;
+    }
+    return next;
+}
+function prefix(service) {
+    return `[${new Date().toISOString()}] [${service}]`;
+}
+function normalizeArgs(service, args) {
+    if (args.length === 0) {
+        return [prefix(service)];
+    }
+    const [first, ...rest] = args;
+    if (typeof first === "string") {
+        return [`${prefix(service)} ${first}`, ...rest];
+    }
+    if (first && typeof first === "object" && !Array.isArray(first)) {
+        return [prefix(service), normalizeErrorRecord(first), ...rest];
+    }
+    return [prefix(service), first, ...rest];
+}
+function write(level, service, ...args) {
+    if (!shouldLog(level))
+        return;
+    const out = normalizeArgs(service, args);
+    if (level === "error" || level === "fatal") {
+        console.error(...out);
+        return;
+    }
+    if (level === "warn") {
+        console.warn(...out);
+        return;
+    }
+    console.log(...out);
+}
+function createLogger(service) {
+    return {
+        debug: (...args) => write("debug", service, ...args),
+        info: (...args) => write("info", service, ...args),
+        warn: (...args) => write("warn", service, ...args),
+        error: (...args) => write("error", service, ...args),
+        fatal: (...args) => write("fatal", service, ...args),
+    };
+}

package/dist/mqtt/emqx-mqtt.service.d.ts

@@ -0,0 +1,44 @@
+import mqtt from "mqtt";
+import { MqttTopicRunner } from "./mqtt.type";
+export interface MqttConfig {
+    url: string;
+    clientId?: string;
+    username?: string;
+    password?: string;
+    will?: any;
+}
+export type MqttQos = 0 | 1 | 2;
+export interface MqttMessageContext {
+    topic: string;
+    payload: Buffer;
+    match?: string;
+}
+export interface MqttHandlerRegistration {
+    id?: string;
+    topicPattern: string;
+    qos: MqttQos;
+    handler: (ctx: MqttMessageContext) => Promise<void> | void;
+}
+export declare class EmqxMqttService {
+    client: mqtt.MqttClient;
+    private handlerMap;
+    private topicHandlerMap;
+    private hasConnectedOnce;
+    private readonly logger;
+    init(config: MqttConfig): Promise<void>;
+    private onError;
+    private onMessage;
+    private onConnect;
+    private subscribe;
+    private isTopicMatch;
+    private isWildcardPattern;
+    private getMatchValue;
+    publish(topic: string, message: string | Buffer, opts: mqtt.IClientPublishOptions): Promise<void>;
+    subscribeHandler(registration: MqttHandlerRegistration): Promise<string>;
+    unsubscribeHandler(id: string): Promise<void>;
+    registerService(service: MqttTopicRunner): Promise<string>;
+    unregisterService(id: string): Promise<void>;
+    clearService(): Promise<void>;
+}
+export declare class EMQXMqttService extends EmqxMqttService {
+}

package/dist/mqtt/emqx-mqtt.service.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMQXMqttService = exports.EmqxMqttService = void 0;
+const mqtt_1 = __importDefault(require("mqtt"));
+const crypto_1 = require("crypto");
+const mqtt_pattern_1 = __importDefault(require("mqtt-pattern"));
+const logger_1 = require("../logger");
+class EmqxMqttService {
+    constructor() {
+        this.handlerMap = new Map();
+        this.topicHandlerMap = new Map();
+        this.hasConnectedOnce = false;
+        this.logger = (0, logger_1.createLogger)(EmqxMqttService.name);
+    }
+    async init(config) {
+        this.client = mqtt_1.default.connect(config.url, {
+            clientId: config.clientId || "mqtt-js-" + (0, crypto_1.randomUUID)(),
+            username: config.username,
+            password: config.password,
+            reconnectPeriod: 1000,
+            connectTimeout: 30000,
+            keepalive: 60,
+            resubscribe: true,
+        });
+        this.client.on("message", async (topic, message) => {
+            await this.onMessage(topic, message);
+        });
+        this.client.on("connect", async () => {
+            await this.onConnect();
+        });
+        this.client.on("close", () => {
+            if (this.hasConnectedOnce) {
+                this.logger.warn("mqtt.connection.closed");
+            }
+            else {
+                this.logger.info("mqtt.connection.closed.startup");
+            }
+        });
+        this.client.on("offline", () => {
+            if (this.hasConnectedOnce) {
+                this.logger.warn("mqtt.connection.offline");
+            }
+            else {
+                this.logger.info("mqtt.connection.offline.startup");
+            }
+        });
+        this.client.on("reconnect", () => {
+            if (this.hasConnectedOnce) {
+                this.logger.warn("mqtt.connection.reconnecting");
+            }
+            else {
+                this.logger.info("mqtt.connection.reconnecting.startup");
+            }
+        });
+        this.client.on("end", () => {
+            this.logger.warn("mqtt.connection.ended");
+        });
+        this.client.on("disconnect", (packet) => {
+            this.logger.warn({ packet }, "mqtt.connection.disconnected");
+        });
+        this.client.on("error", async (e) => {
+            if (this.hasConnectedOnce) {
+                this.logger.error({ err: e }, "mqtt.connection.error");
+            }
+            else {
+                this.logger.warn({ err: e }, "mqtt.connection.error.startup");
+            }
+            await this.onError();
+        });
+        await new Promise((resolve, reject) => {
+            const timeoutMs = 90000;
+            const timer = setTimeout(() => {
+                reject(new Error(`mqtt.init.timeout.${timeoutMs}ms`));
+            }, timeoutMs);
+            this.client.once("connect", () => {
+                clearTimeout(timer);
+                resolve(1);
+            });
+        });
+    }
+    async onError() {
+        this.logger.info("mqtt.error.handled");
+    }
+    async onMessage(topic, message) {
+        this.logger.debug({ topic, payloadSize: message.length }, "mqtt.message.received");
+        for (const [pattern, groupMap] of this.topicHandlerMap.entries()) {
+            if (!this.isTopicMatch(pattern, topic)) {
+                continue;
+            }
+            const matchValue = this.getMatchValue(pattern, topic);
+            for (const registration of groupMap.values()) {
+                this.logger.debug({ topic, topicPattern: registration.topicPattern, match: matchValue }, "mqtt.message.matched");
+                await registration.handler({ topic, payload: message, match: matchValue });
+            }
+        }
+    }
+    async onConnect() {
+        this.hasConnectedOnce = true;
+        this.logger.info("mqtt.connection.connected");
+        const topicQosMap = new Map();
+        for (const [topicPattern, groupMap] of this.topicHandlerMap.entries()) {
+            let maxQos = 0;
+            for (const registration of groupMap.values()) {
+                maxQos = Math.max(maxQos, registration.qos);
+            }
+            topicQosMap.set(topicPattern, maxQos);
+        }
+        for (const [topic, qos] of topicQosMap.entries()) {
+            await this.subscribe(topic, { qos });
+        }
+        if (topicQosMap.size > 0) {
+            this.logger.info({ count: topicQosMap.size }, "mqtt.subscription.restored");
+        }
+    }
+    async subscribe(topic, opts) {
+        await new Promise((resolve, reject) => {
+            this.client.subscribe(topic, opts, (err, granted) => {
+                if (err) {
+                    this.logger.error({ err, topic }, "mqtt.subscription.failed");
+                    reject(err);
+                    return;
+                }
+                this.logger.info({ topic, granted }, "mqtt.subscription.succeeded");
+                resolve();
+            });
+        });
+    }
+    isTopicMatch(pattern, topic) {
+        if (!this.isWildcardPattern(pattern)) {
+            return pattern === topic;
+        }
+        return mqtt_pattern_1.default.matches(pattern, topic);
+    }
+    isWildcardPattern(pattern) {
+        return pattern.includes("+") || pattern.includes("#");
+    }
+    getMatchValue(pattern, topic) {
+        if (!this.isWildcardPattern(pattern)) {
+            return topic;
+        }
+        const plusIdx = pattern.indexOf("+");
+        const hashIdx = pattern.indexOf("#");
+        const idxList = [plusIdx, hashIdx].filter((idx) => idx >= 0);
+        if (idxList.length === 0) {
+            return topic;
+        }
+        const firstWildcardIndex = Math.min(...idxList);
+        const prefix = pattern.slice(0, firstWildcardIndex);
+        return topic.startsWith(prefix) ? (topic.slice(prefix.length) || "") : topic;
+    }
+    async publish(topic, message, opts) {
+        const payloadSize = typeof message === "string" ? Buffer.byteLength(message) : message.length;
+        this.logger.debug({ topic, payloadSize }, "mqtt.message.publishing");
+        await this.client.publish(topic, message, opts);
+    }
+    async subscribeHandler(registration) {
+        registration.id = registration.id || (0, crypto_1.randomUUID)();
+        this.handlerMap.set(registration.id, registration);
+        const groupMap = this.topicHandlerMap.get(registration.topicPattern);
+        const isNewTopic = !groupMap;
+        if (groupMap) {
+            groupMap.set(registration.id, registration);
+        }
+        else {
+            const gMap = new Map();
+            gMap.set(registration.id, registration);
+            this.topicHandlerMap.set(registration.topicPattern, gMap);
+        }
+        if (isNewTopic) {
+            await this.subscribe(registration.topicPattern, { qos: registration.qos });
+        }
+        this.logger.info({ topicPattern: registration.topicPattern, qos: registration.qos }, "mqtt.handler.registered");
+        return registration.id;
+    }
+    async unsubscribeHandler(id) {
+        const registration = this.handlerMap.get(id);
+        if (!registration) {
+            return;
+        }
+        const groupMap = this.topicHandlerMap.get(registration.topicPattern);
+        if (groupMap) {
+            groupMap.delete(id);
+            if (groupMap.size === 0) {
+                this.topicHandlerMap.delete(registration.topicPattern);
+                this.client.unsubscribe(registration.topicPattern);
+            }
+        }
+        this.handlerMap.delete(id);
+    }
+    async registerService(service) {
+        return this.subscribeHandler({
+            id: service.id,
+            topicPattern: service.topic,
+            qos: service.qos,
+            handler: async ({ topic, payload, match }) => {
+                await service.callback(topic, payload, match);
+            },
+        });
+    }
+    async unregisterService(id) {
+        await this.unsubscribeHandler(id);
+    }
+    async clearService() {
+        for (const topic of this.topicHandlerMap.keys()) {
+            this.client.unsubscribe(topic);
+        }
+        this.handlerMap.clear();
+        this.topicHandlerMap.clear();
+    }
+}
+exports.EmqxMqttService = EmqxMqttService;
+class EMQXMqttService extends EmqxMqttService {
+}
+exports.EMQXMqttService = EMQXMqttService;

package/dist/mqtt/mqtt.type.d.ts

@@ -0,0 +1,7 @@
+export declare class MqttTopicRunner {
+    id?: string;
+    name?: string;
+    topic: string;
+    qos: 0 | 1 | 2;
+    callback: (topic: string, message: Buffer, match?: string) => any;
+}

package/dist/mqtt/mqtt.type.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MqttTopicRunner = void 0;
+const crypto_1 = require("crypto");
+class MqttTopicRunner {
+    constructor() {
+        this.id = (0, crypto_1.randomUUID)();
+        this.name = (0, crypto_1.randomUUID)();
+        this.qos = 0;
+    }
+}
+exports.MqttTopicRunner = MqttTopicRunner;

package/dist/pg.service.d.ts

@@ -0,0 +1,17 @@
+import * as pg from "pg";
+export declare class PGClientConfig {
+    host: string;
+    port: number;
+    database: string;
+    username: string;
+    password: string;
+    ssl?: any;
+    max?: number;
+}
+export declare class PGClient {
+    private pool;
+    init(config: PGClientConfig): Promise<void>;
+    query(sql: string, params?: any[]): Promise<any[]>;
+    queryOne(sql: string, params?: any[]): Promise<any>;
+    transaction(callback: (client: pg.PoolClient) => any): Promise<void>;
+}

package/dist/pg.service.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PGClient = exports.PGClientConfig = void 0;
+const pg = __importStar(require("pg"));
+const humps_1 = require("humps");
+class PGClientConfig {
+    constructor() {
+        this.ssl = false;
+        this.max = 4;
+    }
+}
+exports.PGClientConfig = PGClientConfig;
+class PGClient {
+    async init(config) {
+        const pgConfig = {
+            host: config.host,
+            port: config.port,
+            database: config.database,
+            user: config.username,
+            password: config.password,
+            max: config.max,
+        };
+        if (config.ssl) {
+            pgConfig.ssl = {
+                rejectUnauthorized: false
+            };
+        }
+        this.pool = new pg.Pool(pgConfig);
+        const client = await this.pool.connect();
+        await client.query("select now()");
+        await client.release();
+    }
+    async query(sql, params) {
+        let result = [];
+        let error;
+        const client = await this.pool.connect();
+        try {
+            const { rows } = await client.query(sql, params);
+            result = (0, humps_1.camelizeKeys)(rows);
+        }
+        catch (e) {
+            console.error("db error.", e.stack);
+            error = e;
+        }
+        finally {
+            await client.release();
+        }
+        if (error) {
+            throw new Error(String(error));
+        }
+        return result;
+    }
+    async queryOne(sql, params) {
+        let result;
+        const client = await this.pool.connect();
+        try {
+            const { rows } = await client.query(sql, params);
+            result = (0, humps_1.camelizeKeys)(rows[0]) || {};
+        }
+        catch (e) {
+            console.error("db error.", e);
+            throw new Error(String(e));
+        }
+        finally {
+            await client.release();
+        }
+        return result;
+    }
+    async transaction(callback) {
+        const client = await this.pool.connect();
+        await client.query("BEGIN");
+        try {
+            await callback(client);
+            await client.query("COMMIT");
+            await client.release();
+        }
+        catch (e) {
+            console.error("Transaction error.", e);
+            await client.query("ROLLBACK");
+            await client.release();
+            throw e;
+        }
+    }
+}
+exports.PGClient = PGClient;

package/dist/redis.service.d.ts

@@ -0,0 +1,21 @@
+import Redis from "ioredis";
+export declare class RedisClientConfig {
+    host: string;
+    port: number;
+    db: number;
+    username?: string;
+    password?: string;
+    tls?: any;
+    keyPrefix?: string;
+    cluster?: boolean;
+}
+export declare class RedisClient {
+    client: Redis;
+    private config;
+    init(config: RedisClientConfig): Promise<void>;
+    set(key: string, value: any, expire?: number): Promise<void>;
+    get(key: string): Promise<string | null>;
+    setJsonValue(key: string, value: any): Promise<"OK">;
+    getJsonValue(key: string): Promise<any>;
+    exists(key: string): Promise<number>;
+}

package/dist/redis.service.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClient = exports.RedisClientConfig = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+class RedisClientConfig {
+}
+exports.RedisClientConfig = RedisClientConfig;
+class RedisClient {
+    constructor() {
+        this.config = null;
+    }
+    async init(config) {
+        this.config = config;
+        try {
+            this.client = new ioredis_1.default({
+                host: config.host,
+                port: config.port,
+                db: config.db,
+                username: config.username,
+                password: config.password,
+                disableClientInfo: true,
+                tls: config.tls || false,
+                reconnectOnError: (err) => {
+                    console.warn("Reconnect on error:", err);
+                    return true;
+                },
+                retryStrategy: (times) => {
+                    const delay = Math.min(times * 50, 2000);
+                    console.info(`Retrying connection in ${delay}ms`);
+                    return delay;
+                },
+            });
+            this.client.on("error", (err) => {
+                console.error("Redis Error:", err);
+            });
+            const result = await this.client.ping();
+            console.debug(result);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    async set(key, value, expire) {
+        const client = this.client;
+        try {
+            await client.multi().set(key, value).expire(key, expire || 300).exec();
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    async get(key) {
+        return await this.client.get(key);
+    }
+    async setJsonValue(key, value) {
+        return await this.client.set(key, JSON.stringify(value, null, 2));
+    }
+    async getJsonValue(key) {
+        const s = await this.client.get(key);
+        let r = {};
+        try {
+            r = JSON.parse(s);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return r;
+    }
+    async exists(key) {
+        return await this.client.exists(key);
+    }
+}
+exports.RedisClient = RedisClient;

package/dist/rmq.service.d.ts

@@ -0,0 +1,44 @@
+import * as amqp from "amqplib";
+import { Channel } from "amqplib";
+export declare class QueueItem {
+    queue: string;
+    prefetch?: number;
+}
+export declare class ExchangeItem {
+    exchange: string;
+    queue: string;
+    routingKey: string;
+}
+export declare class RMQConfig {
+    host: string;
+    port: number;
+    vhost: string;
+    username: string;
+    password: string;
+}
+export declare class RmqService {
+    private readonly logger;
+    private config;
+    private connection;
+    private channelMap;
+    private consumerMap;
+    private consumingQueues;
+    private pubList;
+    private subList;
+    private reconnectPromise;
+    private readonly maxReconnectAttempts;
+    private readonly reconnectBaseDelayMs;
+    private readonly reconnectMaxDelayMs;
+    private initialized;
+    init(config: RMQConfig, pubList: ExchangeItem[], subList: QueueItem[]): Promise<void>;
+    private ensureReady;
+    private ensureConnection;
+    private handleDisconnect;
+    private reconnectWithBackoff;
+    createPublishChannel(): Promise<void>;
+    private restoreConsumers;
+    private startConsume;
+    private closeAndClearChannels;
+    publishToExchange(exchange: string, routingKey: string | undefined, message: any, options?: amqp.Options.Publish): Promise<void>;
+    consumer(queue: string, callback: (data: amqp.ConsumeMessage, channel: Channel) => any): Promise<void>;
+}

package/dist/rmq.service.js

@@ -0,0 +1,228 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RmqService = exports.RMQConfig = exports.ExchangeItem = exports.QueueItem = void 0;
+const amqp = __importStar(require("amqplib"));
+const logger_1 = require("./logger");
+class QueueItem {
+}
+exports.QueueItem = QueueItem;
+class ExchangeItem {
+}
+exports.ExchangeItem = ExchangeItem;
+class RMQConfig {
+}
+exports.RMQConfig = RMQConfig;
+class RmqService {
+    constructor() {
+        this.logger = (0, logger_1.createLogger)("RmqService");
+        this.config = null;
+        this.connection = null;
+        this.channelMap = new Map();
+        this.consumerMap = new Map();
+        this.consumingQueues = new Set();
+        this.pubList = [];
+        this.subList = [];
+        this.reconnectPromise = null;
+        this.maxReconnectAttempts = Number(process.env.RMQ_MAX_RECONNECT_ATTEMPTS || 20);
+        this.reconnectBaseDelayMs = Number(process.env.RMQ_RECONNECT_BASE_DELAY_MS || 1000);
+        this.reconnectMaxDelayMs = Number(process.env.RMQ_RECONNECT_MAX_DELAY_MS || 30000);
+        this.initialized = false;
+    }
+    async init(config, pubList, subList) {
+        this.config = config;
+        this.pubList = pubList || [];
+        this.subList = subList || [];
+        this.initialized = true;
+        await this.ensureReady(false);
+    }
+    async ensureReady(restoreConsumers) {
+        await this.ensureConnection();
+        await this.createPublishChannel();
+        if (restoreConsumers) {
+            await this.restoreConsumers();
+        }
+    }
+    async ensureConnection() {
+        if (this.connection)
+            return;
+        if (!this.config) {
+            throw new Error("rmq config is not initialized");
+        }
+        this.connection = await amqp.connect({
+            protocol: "amqp",
+            hostname: this.config.host,
+            port: this.config.port,
+            username: this.config.username,
+            password: this.config.password,
+            vhost: this.config.vhost,
+        }, {
+            clientProperties: {
+                connection_name: "1",
+            },
+        });
+        this.connection.on("error", (err) => {
+            this.logger.error({ error: err }, "rmq.connection.error");
+            this.handleDisconnect("error");
+        });
+        this.connection.on("close", () => {
+            this.logger.warn("rmq.connection.closed");
+            this.handleDisconnect("close");
+        });
+        this.logger.info("rmq.connection.ready");
+    }
+    handleDisconnect(reason) {
+        if (!this.initialized)
+            return;
+        if (this.reconnectPromise)
+            return;
+        this.connection = null;
+        this.closeAndClearChannels();
+        this.reconnectPromise = this.reconnectWithBackoff(reason).finally(() => {
+            this.reconnectPromise = null;
+        });
+    }
+    async reconnectWithBackoff(reason) {
+        for (let attempt = 1;; attempt++) {
+            try {
+                await this.ensureReady(true);
+                this.logger.info({ reason }, "rmq.reconnect.ready");
+                return;
+            }
+            catch (err) {
+                this.logger.error({ attempt, error: err }, "rmq.reconnect.failed");
+                if (this.maxReconnectAttempts > 0 && attempt >= this.maxReconnectAttempts) {
+                    this.logger.fatal({ attempts: attempt }, "rmq.reconnect.max_attempts_reached.exit");
+                    process.exit(1);
+                }
+                const delayMs = Math.min(this.reconnectBaseDelayMs * Math.pow(2, attempt - 1), this.reconnectMaxDelayMs);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+    }
+    async createPublishChannel() {
+        if (!this.connection) {
+            throw new Error("RabbitMQ connection is not ready");
+        }
+        for (const item of this.pubList) {
+            if (this.channelMap.has(item.exchange + item.routingKey)) {
+                continue;
+            }
+            const channel = await this.connection.createConfirmChannel();
+            await channel.assertExchange(item.exchange, "fanout", { autoDelete: false });
+            await channel.assertQueue(item.queue, { autoDelete: false });
+            await channel.bindQueue(item.queue, item.exchange, item.routingKey);
+            this.channelMap.set(item.exchange + item.routingKey, channel);
+        }
+        for (const item of this.subList) {
+            if (this.channelMap.has(item.queue)) {
+                continue;
+            }
+            const channel = await this.connection.createChannel();
+            await channel.assertQueue(item.queue);
+            await channel.prefetch(item.prefetch || 1);
+            this.channelMap.set(item.queue, channel);
+        }
+    }
+    async restoreConsumers() {
+        for (const [queue, callback] of this.consumerMap.entries()) {
+            await this.startConsume(queue, callback);
+        }
+    }
+    async startConsume(queue, callback) {
+        if (this.consumingQueues.has(queue)) {
+            return;
+        }
+        const channel = this.channelMap.get(queue);
+        if (!channel) {
+            throw new Error(`consumer channel not found for queue: ${queue}`);
+        }
+        this.logger.info({ queue }, "rmq.consumer.start");
+        await channel.consume(queue, async (data) => {
+            if (!data)
+                return;
+            try {
+                await callback(data, channel);
+            }
+            catch (error) {
+                this.logger.error({ queue, error }, "rmq.consumer.callback_failed");
+            }
+        });
+        this.consumingQueues.add(queue);
+    }
+    closeAndClearChannels() {
+        this.channelMap.forEach((c) => {
+            try {
+                c.close();
+            }
+            catch (_e) {
+            }
+        });
+        this.channelMap.clear();
+        this.consumingQueues.clear();
+    }
+    async publishToExchange(exchange, routingKey = "", message, options) {
+        if (this.reconnectPromise) {
+            await this.reconnectPromise;
+        }
+        let ch = this.channelMap.get(exchange + routingKey);
+        if (!ch) {
+            await this.ensureReady(false);
+            ch = this.channelMap.get(exchange + routingKey);
+        }
+        if (!ch) {
+            throw new Error(`publish channel not found: ${exchange}:${routingKey}`);
+        }
+        try {
+            ch.publish(exchange, routingKey, Buffer.from(JSON.stringify(message)), options);
+            await ch.waitForConfirms();
+        }
+        catch (error) {
+            this.logger.error({ exchange, routingKey, error }, "rmq.publish.failed");
+            throw error;
+        }
+    }
+    async consumer(queue, callback) {
+        this.consumerMap.set(queue, callback);
+        if (this.reconnectPromise) {
+            await this.reconnectPromise;
+        }
+        if (!this.channelMap.get(queue)) {
+            await this.ensureReady(false);
+        }
+        await this.startConsume(queue, callback);
+    }
+}
+exports.RmqService = RmqService;

package/dist/test/smoke.test.d.ts

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

package/dist/test/smoke.test.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const index_1 = require("../index");
+(0, node_test_1.default)("exports can be constructed", () => {
+    const logger = (0, index_1.createLogger)("smoke");
+    strict_1.default.equal(typeof logger.info, "function");
+    const pg = new index_1.PGClient();
+    const redis = new index_1.RedisClient();
+    const rmq = new index_1.RmqService();
+    const mqtt = new index_1.EmqxMqttService();
+    const mqttCompat = new index_1.EMQXMqttService();
+    const runner = new index_1.MqttTopicRunner();
+    strict_1.default.ok(pg);
+    strict_1.default.ok(redis);
+    strict_1.default.ok(rmq);
+    strict_1.default.ok(mqtt);
+    strict_1.default.ok(mqttCompat);
+    strict_1.default.ok(runner.id);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mango-power/node-kit",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Shared node toolkit for mp services",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,6 +14,7 @@
   "scripts": {
     "build": "npx tsc -p tsconfig.json",
     "typecheck": "npx tsc --noEmit -p tsconfig.json",
+    "test": "npm run build && node --test dist/test/smoke.test.js",
     "prepublishOnly": "npm run build",
     "release": "npm publish --access public"
   },
@@ -23,7 +24,18 @@
     "shared"
   ],
   "license": "ISC",
+  "dependencies": {
+    "amqplib": "^0.10.9",
+    "humps": "^2.0.1",
+    "ioredis": "^5.8.1",
+    "mqtt": "^5.14.1",
+    "mqtt-pattern": "^2.1.1",
+    "pg": "^8.16.3"
+  },
   "devDependencies": {
+    "@types/amqplib": "^0.10.8",
+    "@types/humps": "^2.0.6",
+    "@types/pg": "^8.15.6",
     "@types/node": "^24.11.0",
     "typescript": "^5.9.3"
   }