@mango-power/node-kit 0.0.4 → 0.0.6

package/README.md

@@ -9,6 +9,8 @@ Shared node toolkit package for MP services.
 - `RedisClient`
 - `RmqService`
 - `SLSClient`
+- `AwsMqttService`
+- `AliMqttService`
 - `EmqxMqttService` / `EMQXMqttService`
 
 ## Build
@@ -34,6 +36,6 @@ registry=https://registry.npmjs.org/
 ## Install from other projects
 
 ```bash
-npm i @mango-power/node-kit@^0.0.4
+npm i @mango-power/node-kit@^0.0.6
 ```
 

package/dist/index.d.ts

@@ -4,4 +4,6 @@ export * from "./redis.service";
 export * from "./rmq.service";
 export * from "./sls.service";
 export * from "./mqtt/mqtt.type";
+export * from "./mqtt/aws-mqtt.service";
+export * from "./mqtt/ali-mqtt.service";
 export * from "./mqtt/emqx-mqtt.service";

package/dist/index.js

@@ -20,4 +20,6 @@ __exportStar(require("./redis.service"), exports);
 __exportStar(require("./rmq.service"), exports);
 __exportStar(require("./sls.service"), exports);
 __exportStar(require("./mqtt/mqtt.type"), exports);
+__exportStar(require("./mqtt/aws-mqtt.service"), exports);
+__exportStar(require("./mqtt/ali-mqtt.service"), exports);
 __exportStar(require("./mqtt/emqx-mqtt.service"), exports);

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

@@ -0,0 +1,36 @@
+import mqtt from "mqtt";
+import { AliyunMqttConfig, MqttTopicRunner } from "./mqtt.type";
+type MqttQos = 0 | 1 | 2;
+interface MqttMessageContext {
+    topic: string;
+    payload: Buffer;
+    match?: string;
+}
+interface MqttHandlerRegistration {
+    id?: string;
+    topicPattern: string;
+    qos: MqttQos;
+    handler: (ctx: MqttMessageContext) => Promise<void> | void;
+}
+export declare class AliMqttService {
+    client: mqtt.MqttClient;
+    private handlerMap;
+    private topicHandlerMap;
+    private hasConnectedOnce;
+    private readonly logger;
+    init(config: AliyunMqttConfig): 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>;
+    registerService(service: MqttTopicRunner): Promise<string>;
+    unregisterService(id: string): Promise<void>;
+    subscribeHandler(registration: MqttHandlerRegistration): Promise<string>;
+    unsubscribeHandler(id: string): Promise<void>;
+    clearService(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,244 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliMqttService = void 0;
+const crypto = __importStar(require("crypto"));
+const crypto_1 = require("crypto");
+const mqtt_1 = __importDefault(require("mqtt"));
+const mqtt_pattern_1 = __importDefault(require("mqtt-pattern"));
+const logger_1 = require("../logger");
+function createAliyunMqttClientId(groupName, appName) {
+    return `${groupName}@@@${appName}_${(0, crypto_1.randomUUID)()}`;
+}
+function createAliyunMqttAuthInfo(clientId, instanceId, accessKeyId, accessKeySecret) {
+    const username = `Signature|${accessKeyId}|${instanceId}`;
+    const password = crypto.createHmac("sha1", accessKeySecret).update(clientId).digest("base64");
+    return { username, password };
+}
+class AliMqttService {
+    constructor() {
+        this.handlerMap = new Map();
+        this.topicHandlerMap = new Map();
+        this.hasConnectedOnce = false;
+        this.logger = (0, logger_1.createLogger)(AliMqttService.name);
+    }
+    async init(config) {
+        const clientId = createAliyunMqttClientId("GID_MP_SVC", "iot_svc_task");
+        const { username, password } = createAliyunMqttAuthInfo(clientId, config.instanceId, config.accessKeyId, config.accessKeySecret);
+        this.client = mqtt_1.default.connect(`mqtts://${config.host}:8883`, {
+            clientId,
+            username,
+            password,
+            reconnectPeriod: 1000,
+            connectTimeout: 30000,
+            keepalive: 120,
+            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("ali.mqtt.connection.closed");
+            }
+            else {
+                this.logger.info("ali.mqtt.connection.closed.startup");
+            }
+        });
+        this.client.on("offline", () => {
+            if (this.hasConnectedOnce) {
+                this.logger.warn("ali.mqtt.connection.offline");
+            }
+            else {
+                this.logger.info("ali.mqtt.connection.offline.startup");
+            }
+        });
+        this.client.on("reconnect", () => {
+            if (this.hasConnectedOnce) {
+                this.logger.warn("ali.mqtt.connection.reconnecting");
+            }
+            else {
+                this.logger.info("ali.mqtt.connection.reconnecting.startup");
+            }
+        });
+        this.client.on("end", () => {
+            this.logger.warn("ali.mqtt.connection.ended");
+        });
+        this.client.on("disconnect", (packet) => {
+            this.logger.warn({ packet }, "ali.mqtt.connection.disconnected");
+        });
+        this.client.on("error", async (e) => {
+            if (this.hasConnectedOnce) {
+                this.logger.error({ error: e }, "ali.mqtt.connection.error");
+            }
+            else {
+                this.logger.warn({ error: e }, "ali.mqtt.connection.error.startup");
+            }
+            await this.onError();
+        });
+        await new Promise((resolve, reject) => {
+            const timeoutMs = 90000;
+            const timer = setTimeout(() => reject(new Error(`ali.mqtt.init.timeout.${timeoutMs}ms`)), timeoutMs);
+            this.client.once("connect", () => {
+                clearTimeout(timer);
+                resolve(1);
+            });
+        });
+    }
+    async onError() {
+        this.logger.info("ali.mqtt.error.handled");
+    }
+    async onMessage(topic, message) {
+        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()) {
+                await registration.handler({ topic, payload: message, match: matchValue });
+            }
+        }
+    }
+    async onConnect() {
+        this.hasConnectedOnce = true;
+        this.logger.info("ali.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 });
+        }
+    }
+    async subscribe(topic, opts) {
+        await new Promise((resolve, reject) => {
+            this.client.subscribe(topic, opts, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                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) {
+        await this.client.publish(topic, message, opts);
+    }
+    async registerService(service) {
+        return this.subscribeHandler({
+            id: service.id,
+            topicPattern: service.topic,
+            qos: service.qos,
+            handler: async ({ topic, payload, match }) => service.callback(topic, payload, match),
+        });
+    }
+    async unregisterService(id) {
+        await this.unsubscribeHandler(id);
+    }
+    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 });
+        }
+        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 clearService() {
+        for (const topic of this.topicHandlerMap.keys()) {
+            this.client.unsubscribe(topic);
+        }
+        this.handlerMap.clear();
+        this.topicHandlerMap.clear();
+    }
+}
+exports.AliMqttService = AliMqttService;

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

@@ -0,0 +1,37 @@
+import * as aws from "aws-iot-device-sdk";
+import mqtt from "mqtt";
+import { AwsMqttConfig, MqttTopicRunner } from "./mqtt.type";
+type MqttQos = 0 | 1 | 2;
+interface MqttMessageContext {
+    topic: string;
+    payload: Buffer;
+    match?: string;
+}
+interface MqttHandlerRegistration {
+    id?: string;
+    topicPattern: string;
+    qos: MqttQos;
+    handler: (ctx: MqttMessageContext) => Promise<void> | void;
+}
+export declare class AwsMqttService {
+    client: aws.device;
+    private handlerMap;
+    private topicHandlerMap;
+    private hasConnectedOnce;
+    private readonly logger;
+    init(config: AwsMqttConfig): 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>;
+    registerService(service: MqttTopicRunner): Promise<string>;
+    unregisterService(id: string): Promise<void>;
+    subscribeHandler(registration: MqttHandlerRegistration): Promise<string>;
+    unsubscribeHandler(id: string): Promise<void>;
+    clearService(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,238 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsMqttService = void 0;
+const crypto_1 = require("crypto");
+const aws = __importStar(require("aws-iot-device-sdk"));
+const path = __importStar(require("path"));
+const mqtt_pattern_1 = __importDefault(require("mqtt-pattern"));
+const logger_1 = require("../logger");
+class AwsMqttService {
+    constructor() {
+        this.handlerMap = new Map();
+        this.topicHandlerMap = new Map();
+        this.hasConnectedOnce = false;
+        this.logger = (0, logger_1.createLogger)(AwsMqttService.name);
+    }
+    async init(config) {
+        const pathPrefix = process.cwd();
+        this.client = new aws.device({
+            keyPath: path.resolve(pathPrefix, config.keyPath),
+            certPath: path.resolve(pathPrefix, config.certPath),
+            caPath: path.resolve(pathPrefix, config.caPath),
+            clientId: "mp-iot-service_" + (0, crypto_1.randomUUID)(),
+            host: config.host,
+        });
+        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("aws.mqtt.connection.closed");
+            }
+            else {
+                this.logger.info("aws.mqtt.connection.closed.startup");
+            }
+        });
+        this.client.on("offline", () => {
+            if (this.hasConnectedOnce) {
+                this.logger.warn("aws.mqtt.connection.offline");
+            }
+            else {
+                this.logger.info("aws.mqtt.connection.offline.startup");
+            }
+        });
+        this.client.on("reconnect", () => {
+            if (this.hasConnectedOnce) {
+                this.logger.warn("aws.mqtt.connection.reconnecting");
+            }
+            else {
+                this.logger.info("aws.mqtt.connection.reconnecting.startup");
+            }
+        });
+        this.client.on("close", () => {
+            this.logger.warn("aws.mqtt.connection.ended");
+        });
+        this.client.on("error", async (e) => {
+            if (this.hasConnectedOnce) {
+                this.logger.error({ error: e }, "aws.mqtt.connection.error");
+            }
+            else {
+                this.logger.warn({ error: e }, "aws.mqtt.connection.error.startup");
+            }
+            await this.onError();
+        });
+        await new Promise((resolve, reject) => {
+            const timeoutMs = 90000;
+            const timer = setTimeout(() => reject(new Error(`aws.mqtt.init.timeout.${timeoutMs}ms`)), timeoutMs);
+            this.client.once("connect", () => {
+                clearTimeout(timer);
+                resolve(1);
+            });
+        });
+    }
+    async onError() {
+        this.logger.info("aws.mqtt.error.handled");
+    }
+    async onMessage(topic, message) {
+        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()) {
+                await registration.handler({ topic, payload: message, match: matchValue });
+            }
+        }
+    }
+    async onConnect() {
+        this.hasConnectedOnce = true;
+        this.logger.info("aws.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 });
+        }
+    }
+    async subscribe(topic, opts) {
+        await new Promise((resolve, reject) => {
+            this.client.subscribe(topic, opts, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                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) {
+        await new Promise((resolve, reject) => {
+            this.client.publish(topic, message, opts, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    async registerService(service) {
+        return this.subscribeHandler({
+            id: service.id,
+            topicPattern: service.topic,
+            qos: service.qos,
+            handler: async ({ topic, payload, match }) => service.callback(topic, payload, match),
+        });
+    }
+    async unregisterService(id) {
+        await this.unsubscribeHandler(id);
+    }
+    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 });
+        }
+        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 clearService() {
+        for (const topic of this.topicHandlerMap.keys()) {
+            this.client.unsubscribe(topic);
+        }
+        this.handlerMap.clear();
+        this.topicHandlerMap.clear();
+    }
+}
+exports.AwsMqttService = AwsMqttService;

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

@@ -5,7 +5,7 @@ export interface MqttConfig {
     clientId?: string;
     username?: string;
     password?: string;
-    will?: any;
+    will?: mqtt.IClientOptions["will"];
 }
 export type MqttQos = 0 | 1 | 2;
 export interface MqttMessageContext {

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

@@ -1,3 +1,15 @@
+export interface AliyunMqttConfig {
+    host: string;
+    instanceId: string;
+    accessKeyId: string;
+    accessKeySecret: string;
+}
+export interface AwsMqttConfig {
+    host: string;
+    keyPath: string;
+    certPath: string;
+    caPath: string;
+}
 export declare class MqttTopicRunner {
     id?: string;
     name?: string;

package/dist/pg.service.d.ts

@@ -5,13 +5,14 @@ export declare class PGClientConfig {
     database: string;
     username: string;
     password: string;
-    ssl?: any;
+    ssl?: boolean;
     max?: number;
 }
 export declare class PGClient {
     private pool;
+    private readonly logger;
     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>;
+    query<T = any>(sql: string, params?: readonly unknown[]): Promise<T[]>;
+    queryOne<T = any>(sql: string, params?: readonly unknown[]): Promise<T>;
+    transaction<T>(callback: (client: pg.PoolClient) => Promise<T> | T): Promise<T>;
 }

package/dist/pg.service.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PGClient = exports.PGClientConfig = void 0;
 const pg = __importStar(require("pg"));
 const humps_1 = require("humps");
+const logger_1 = require("./logger");
 class PGClientConfig {
     constructor() {
         this.ssl = false;
@@ -44,6 +45,9 @@ class PGClientConfig {
 }
 exports.PGClientConfig = PGClientConfig;
 class PGClient {
+    constructor() {
+        this.logger = (0, logger_1.createLogger)("PGClient");
+    }
     async init(config) {
         const pgConfig = {
             host: config.host,
@@ -62,17 +66,18 @@ class PGClient {
         const client = await this.pool.connect();
         await client.query("select now()");
         await client.release();
+        this.logger.debug("pg.init.ping.ok");
     }
     async query(sql, params) {
         let result = [];
         let error;
         const client = await this.pool.connect();
         try {
-            const { rows } = await client.query(sql, params);
+            const { rows } = params ? await client.query(sql, [...params]) : await client.query(sql);
             result = (0, humps_1.camelizeKeys)(rows);
         }
         catch (e) {
-            console.error("db error.", e.stack);
+            this.logger.error({ error: e }, "pg.query.failed");
             error = e;
         }
         finally {
@@ -87,11 +92,11 @@ class PGClient {
         let result;
         const client = await this.pool.connect();
         try {
-            const { rows } = await client.query(sql, params);
-            result = (0, humps_1.camelizeKeys)(rows[0]) || {};
+            const { rows } = params ? await client.query(sql, [...params]) : await client.query(sql);
+            result = ((0, humps_1.camelizeKeys)(rows[0]) || {});
         }
         catch (e) {
-            console.error("db error.", e);
+            this.logger.error({ error: e }, "pg.query_one.failed");
             throw new Error(String(e));
         }
         finally {
@@ -103,12 +108,13 @@ class PGClient {
         const client = await this.pool.connect();
         await client.query("BEGIN");
         try {
-            await callback(client);
+            const result = await callback(client);
             await client.query("COMMIT");
             await client.release();
+            return result;
         }
         catch (e) {
-            console.error("Transaction error.", e);
+            this.logger.error({ error: e }, "pg.transaction.failed");
             await client.query("ROLLBACK");
             await client.release();
             throw e;

package/dist/redis.service.d.ts

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

package/dist/redis.service.js

@@ -5,42 +5,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisClient = exports.RedisClientConfig = void 0;
 const ioredis_1 = __importDefault(require("ioredis"));
+const logger_1 = require("./logger");
 class RedisClientConfig {
 }
 exports.RedisClientConfig = RedisClientConfig;
 class RedisClient {
     constructor() {
-        this.config = null;
+        this.logger = (0, logger_1.createLogger)("RedisClient");
     }
     async init(config) {
-        this.config = config;
         try {
-            this.client = new ioredis_1.default({
+            const redisOptions = {
                 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);
+                    this.logger.warn({ error: err }, "redis.reconnect_on_error");
                     return true;
                 },
                 retryStrategy: (times) => {
                     const delay = Math.min(times * 50, 2000);
-                    console.info(`Retrying connection in ${delay}ms`);
+                    this.logger.info({ delayMs: delay, retryTimes: times }, "redis.retry_scheduled");
                     return delay;
                 },
-            });
+            };
+            if (config.tls) {
+                redisOptions.tls = config.tls;
+            }
+            this.client = new ioredis_1.default(redisOptions);
             this.client.on("error", (err) => {
-                console.error("Redis Error:", err);
+                this.logger.error({ error: err }, "redis.client.error");
             });
-            const result = await this.client.ping();
-            console.debug(result);
+            await this.client.ping();
+            this.logger.debug("redis.ping.ok");
         }
         catch (e) {
-            console.error(e);
+            this.logger.error({ error: e }, "redis.init.failed");
         }
     }
     async set(key, value, expire) {
@@ -49,7 +52,7 @@ class RedisClient {
             await client.multi().set(key, value).expire(key, expire || 300).exec();
         }
         catch (e) {
-            console.error(e);
+            this.logger.error({ error: e, key }, "redis.set.failed");
         }
     }
     async get(key) {
@@ -60,14 +63,16 @@ class RedisClient {
     }
     async getJsonValue(key) {
         const s = await this.client.get(key);
-        let r = {};
+        if (!s) {
+            return null;
+        }
         try {
-            r = JSON.parse(s);
+            return JSON.parse(s);
         }
         catch (e) {
-            console.error(e);
+            this.logger.error({ error: e, key }, "redis.get_json.parse_failed");
+            return null;
         }
-        return r;
     }
     async exists(key) {
         return await this.client.exists(key);

package/dist/rmq.service.d.ts

@@ -1,5 +1,7 @@
 import * as amqp from "amqplib";
 import { Channel } from "amqplib";
+export type ConsumeMessage = amqp.ConsumeMessage;
+export type RmqConsumeCallback = (data: ConsumeMessage, channel: Channel) => Promise<void> | void;
 export declare class QueueItem {
     queue: string;
     prefetch?: number;
@@ -39,6 +41,6 @@ export declare class RmqService {
     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>;
+    publishToExchange(exchange: string, routingKey: string | undefined, message: unknown, options?: amqp.Options.Publish): Promise<void>;
+    consumer(queue: string, callback: RmqConsumeCallback): Promise<void>;
 }

package/dist/sls.service.d.ts

@@ -3,7 +3,10 @@ export interface SLSServiceConfig {
     accessKeyId: string;
     accessKeySecret: string;
 }
+export interface SlsLogClient {
+    postLogStoreLogs: (projectName: string, logstoreName: string, logGroup: unknown) => Promise<unknown>;
+}
 export declare class SLSClient {
-    client: any;
+    client: SlsLogClient;
     init(config: SLSServiceConfig): Promise<void>;
 }

package/dist/test/smoke.test.js

@@ -13,6 +13,8 @@ const index_1 = require("../index");
     const redis = new index_1.RedisClient();
     const rmq = new index_1.RmqService();
     const sls = new index_1.SLSClient();
+    const awsMqtt = new index_1.AwsMqttService();
+    const aliMqtt = new index_1.AliMqttService();
     const mqtt = new index_1.EmqxMqttService();
     const mqttCompat = new index_1.EMQXMqttService();
     const runner = new index_1.MqttTopicRunner();
@@ -20,6 +22,8 @@ const index_1 = require("../index");
     strict_1.default.ok(redis);
     strict_1.default.ok(rmq);
     strict_1.default.ok(sls);
+    strict_1.default.ok(awsMqtt);
+    strict_1.default.ok(aliMqtt);
     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.4",
+  "version": "0.0.6",
   "description": "Shared node toolkit for mp services",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,6 +27,7 @@
   "dependencies": {
     "@alicloud/log": "^1.2.6",
     "amqplib": "^0.10.9",
+    "aws-iot-device-sdk": "^2.2.16",
     "humps": "^2.0.1",
     "ioredis": "^5.8.1",
     "mqtt": "^5.14.1",
@@ -35,6 +36,7 @@
   },
   "devDependencies": {
     "@types/amqplib": "^0.10.8",
+    "@types/aws-iot-device-sdk": "^2.2.8",
     "@types/humps": "^2.0.6",
     "@types/pg": "^8.15.6",
     "@types/node": "^24.11.0",