imean-service-engine 1.0.0

package/dist/mod.cjs

@@ -0,0 +1,1217 @@
+'use strict';
+
+var zod = require('zod');
+var nodeServer = require('@hono/node-server');
+var ejson3 = require('ejson');
+var etcd3 = require('etcd3');
+var fs = require('fs-extra');
+var hono = require('hono');
+var lruCache = require('lru-cache');
+var winston = require('winston');
+var api = require('@opentelemetry/api');
+var apiLogs = require('@opentelemetry/api-logs');
+var crypto2 = require('crypto');
+var zlib = require('zlib');
+var nodeWs = require('@hono/node-ws');
+var dayjs = require('dayjs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ejson3__default = /*#__PURE__*/_interopDefault(ejson3);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var winston__default = /*#__PURE__*/_interopDefault(winston);
+var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
+var dayjs__default = /*#__PURE__*/_interopDefault(dayjs);
+
+// mod.ts
+var ACTION_METADATA = Symbol("action:metadata");
+function Action(options) {
+  options.params = options.params || [];
+  options.returns = options.returns || zod.z.void();
+  options.cache = options.cache ?? false;
+  options.ttl = options.ttl ?? 0;
+  options.stream = options.stream ?? false;
+  return function(target, context) {
+    const methodName = context.name;
+    context.addInitializer(function() {
+      const prototype = this.constructor.prototype;
+      const func = target.toString().split("\n")[0];
+      const params = func.slice(func.indexOf("(") + 1, func.indexOf(")")).split(",").map((p) => p.split("=").shift()).filter((param) => !!param?.trim());
+      params.forEach((param, index) => {
+        options.params[index] = options.params[index]?.describe(
+          param.trim()
+        );
+      });
+      const existingMetadata = prototype[ACTION_METADATA] || {};
+      existingMetadata[methodName] = {
+        name: methodName,
+        description: options.description || "",
+        params: options.params,
+        returns: options.returns,
+        idempotence: options.idempotence ?? false,
+        printError: options.printError ?? false,
+        cache: options.cache,
+        ttl: options.ttl,
+        stream: options.stream
+      };
+      prototype[ACTION_METADATA] = existingMetadata;
+    });
+  };
+}
+function getActionMetadata(target) {
+  return target.constructor.prototype[ACTION_METADATA] ?? {};
+}
+
+// decorators/module.ts
+var moduleMetadataMap = /* @__PURE__ */ new WeakMap();
+function Module(name, options = {}) {
+  return function(target, _context) {
+    const metadata = {
+      name,
+      options: {
+        name: options.name || name,
+        version: options.version || "1.0.0",
+        description: options.description || "",
+        printError: options.printError ?? false
+      }
+    };
+    moduleMetadataMap.set(target, metadata);
+  };
+}
+function getModuleMetadata(target) {
+  return moduleMetadataMap.get(target);
+}
+
+// core/types.ts
+var ScheduleMode = /* @__PURE__ */ ((ScheduleMode2) => {
+  ScheduleMode2["FIXED_RATE"] = "FIXED_RATE";
+  ScheduleMode2["FIXED_DELAY"] = "FIXED_DELAY";
+  return ScheduleMode2;
+})(ScheduleMode || {});
+var logger = winston__default.default.createLogger({
+  level: "info",
+  transports: [
+    new winston__default.default.transports.Console({
+      level: "info",
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }),
+        winston.format.printf((info) => {
+          const splat = info[Symbol.for("splat")];
+          const msg = `${info.level} ${info.timestamp}: ${info.message} ${!!splat ? JSON.stringify(splat) : ""}`;
+          return msg;
+        })
+      )
+    })
+  ]
+});
+var logger_default = logger;
+
+// decorators/schedule.ts
+var SCHEDULE_METADATA = Symbol("schedule:metadata");
+function Schedule(options) {
+  return function(_originalMethod, context) {
+    const methodName = context.name.toString();
+    context.addInitializer(function() {
+      const prototype = this.constructor.prototype;
+      const moduleMetadata = getModuleMetadata(this.constructor);
+      if (!moduleMetadata) {
+        throw new Error(
+          `Class ${this.constructor.name} is not decorated with @Module decorator`
+        );
+      }
+      const existingMetadata = prototype[SCHEDULE_METADATA] || {};
+      existingMetadata[methodName] = {
+        name: methodName,
+        interval: options.interval,
+        mode: options.mode || "FIXED_RATE" /* FIXED_RATE */
+      };
+      prototype[SCHEDULE_METADATA] = existingMetadata;
+    });
+  };
+}
+function getScheduleMetadata(target) {
+  return target.constructor.prototype[SCHEDULE_METADATA] ?? {};
+}
+var Scheduler = class {
+  constructor(etcdClient) {
+    this.etcdClient = etcdClient;
+  }
+  campaigns = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  isLeader = /* @__PURE__ */ new Map();
+  /**
+   * 启动调度任务
+   */
+  async startSchedule(serviceId, moduleName, methodName, electionKey, metadata, method) {
+    const election = this.etcdClient.election(electionKey, 10);
+    const observe = await election.observe();
+    observe.on("change", (leader) => {
+      const isLeader = leader === serviceId;
+      this.isLeader.set(serviceId, isLeader);
+      if (!isLeader) {
+        this.stopTimer(serviceId);
+      }
+    });
+    const campaign = election.campaign(serviceId);
+    this.campaigns.set(serviceId, campaign);
+    campaign.on("error", (error) => {
+      logger_default.error(`Error in campaign for ${moduleName}.${methodName}:`, error);
+    });
+    campaign.on("elected", () => {
+      this.isLeader.set(serviceId, true);
+      this.startTimer(serviceId, metadata, method);
+      logger_default.info(`become leader for ${moduleName}.${methodName}`);
+    });
+  }
+  /**
+   * 启动定时器
+   */
+  startTimer(serviceId, metadata, method) {
+    this.stopTimer(serviceId);
+    if (metadata.mode === "FIXED_DELAY" /* FIXED_DELAY */) {
+      const runTask = async () => {
+        if (!this.isLeader.get(serviceId)) return;
+        try {
+          await method();
+        } finally {
+          this.timers.set(serviceId, setTimeout(runTask, metadata.interval));
+        }
+      };
+      runTask();
+    } else {
+      this.timers.set(
+        serviceId,
+        setInterval(async () => {
+          if (!this.isLeader.get(serviceId)) return;
+          await method();
+        }, metadata.interval)
+      );
+    }
+  }
+  /**
+   * 停止定时器
+   */
+  stopTimer(serviceId) {
+    const timer = this.timers.get(serviceId);
+    if (timer) {
+      clearTimeout(timer);
+      clearInterval(timer);
+      this.timers.delete(serviceId);
+    }
+  }
+  /**
+   * 停止所有调度任务
+   */
+  async stop() {
+    for (const serviceId of this.timers.keys()) {
+      this.stopTimer(serviceId);
+    }
+    for (const [serviceId, campaign] of this.campaigns.entries()) {
+      try {
+        await campaign.resign().catch(() => {
+        });
+      } catch (error) {
+        console.error(`Error stopping schedule ${serviceId}:`, error);
+      } finally {
+        this.campaigns.delete(serviceId);
+        this.isLeader.delete(serviceId);
+      }
+    }
+  }
+};
+
+// utils/format.ts
+async function formatCode(code) {
+  try {
+    return code;
+  } catch {
+    return code;
+  }
+}
+
+// core/generator.ts
+function getZodTypeString(schema, defaultOptional = false) {
+  function processType(type) {
+    const def = type._def;
+    if (def.typeName === "ZodNullable") {
+      return `${processType(def.innerType)} | null`;
+    }
+    if (def.typeName === "ZodOptional") {
+      return processType(def.innerType);
+    }
+    switch (def.typeName) {
+      case "ZodString": {
+        return "string";
+      }
+      case "ZodNumber": {
+        return "number";
+      }
+      case "ZodBoolean": {
+        return "boolean";
+      }
+      case "ZodArray": {
+        const elementType = processType(def.type);
+        return `${elementType}[]`;
+      }
+      case "ZodDate": {
+        return "Date";
+      }
+      case "ZodObject": {
+        const shape = def.shape();
+        const props = Object.entries(shape).map(([key, value]) => {
+          const fieldDef = value._def;
+          const isOptional = fieldDef.typeName === "ZodOptional";
+          const isDefault = defaultOptional && fieldDef.typeName === "ZodDefault";
+          const fieldType = processType(
+            isOptional ? fieldDef.innerType : value
+          );
+          return `${key}${isOptional || isDefault ? "?" : ""}: ${fieldType}`;
+        }).join("; ");
+        return `{ ${props} }`;
+      }
+      case "ZodEnum": {
+        return def.values.map((opt) => `"${opt}"`).join(" | ");
+      }
+      case "ZodUnion": {
+        return def.options.map((opt) => processType(opt)).join(" | ");
+      }
+      case "ZodNull": {
+        return "null";
+      }
+      case "ZodPromise": {
+        return `Promise<${processType(def.type)}>`;
+      }
+      case "ZodVoid": {
+        return "void";
+      }
+      case "ZodRecord": {
+        return `Record<${processType(def.keyType)}, ${processType(def.valueType)}>`;
+      }
+      case "ZodMap": {
+        return `Map<${processType(def.keyType)}, ${processType(def.valueType)}>`;
+      }
+      case "ZodAny": {
+        return "any";
+      }
+      case "ZodUnknown": {
+        return "unknown";
+      }
+      case "ZodEnum ": {
+        return def.values.map((opt) => `"${opt}"`).join(" | ");
+      }
+      case "ZodDefault": {
+        return processType(def.innerType);
+      }
+      default: {
+        if (type.safeParse(new Uint8Array()).success) {
+          return "Uint8Array";
+        }
+        return "unknown";
+      }
+    }
+  }
+  return processType(schema);
+}
+async function generateClientCode(modules) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const imports = [
+    "// \u8FD9\u4E2A\u6587\u4EF6\u662F\u81EA\u52A8\u751F\u6210\u7684\uFF0C\u8BF7\u4E0D\u8981\u624B\u52A8\u4FEE\u6539",
+    `// Generated at ${timestamp}`,
+    "",
+    'import { MicroserviceClient as BaseMicroserviceClient } from "imean-service-client";',
+    'export * from "imean-service-client";',
+    ""
+  ].join("\n");
+  const interfaces = Object.entries(modules).map(([name, module]) => {
+    const methods = Object.entries(module.actions).map(([actionName, action]) => {
+      if (!action.params) {
+        throw new Error(`Missing params for action ${actionName}`);
+      }
+      const params = action.params.map((param, index) => {
+        const name2 = param.description || `arg${index}`;
+        return `${name2}${param.isOptional() ? "?" : ""}: ${getZodTypeString(param, true)}`;
+      }).join(", ");
+      const returnType = action.returns ? getZodTypeString(action.returns) : "void";
+      return `
+        /**
+         * ${action.description}
+         */
+        ${actionName}: (${params}) => Promise<${action.stream ? `AsyncIterable<${returnType}>` : returnType}>;`;
+    }).join("\n    ");
+    const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+    return `export interface ${capitalizedName}Module {
+    ${methods}
+}`;
+  }).join("\n\n");
+  const clientClass = `export class MicroserviceClient extends BaseMicroserviceClient {
+  ${Object.entries(modules).map(([name, module]) => {
+    const methods = Object.entries(module.actions).map(([actionName, action]) => {
+      return `${actionName}: { idempotent: ${!!action.idempotence}, stream: ${!!action.stream} }`;
+    }).join(",\n      ");
+    return `public readonly ${name} = this.registerModule<${name.charAt(0).toUpperCase() + name.slice(1)}Module>("${name}", {
+      ${methods}
+    });`;
+  }).join("\n\n  ")}
+}`;
+  return await formatCode([
+    imports,
+    interfaces,
+    clientClass
+  ].join("\n\n"));
+}
+function hashText(text) {
+  const hash = crypto2__default.default.createHash("sha256");
+  hash.update(text);
+  return hash.digest("hex");
+}
+var brotli = {
+  compress: (data, quality = 6) => {
+    return new Promise((resolve, reject) => {
+      zlib.brotliCompress(
+        data,
+        { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: quality } },
+        (err, compressed) => {
+          if (err) reject(err);
+          else resolve(compressed);
+        }
+      );
+    });
+  },
+  decompress: (data) => {
+    return new Promise((resolve, reject) => {
+      zlib.brotliDecompress(data, (err, decompressed) => {
+        if (err) reject(err);
+        else resolve(decompressed);
+      });
+    });
+  }
+};
+
+// core/handler.ts
+var tracer = api.trace.getTracer("action-handler");
+var logger2 = apiLogs.logs.getLogger("action-handler");
+var ActionHandler = class {
+  constructor(moduleInstance, actionName, metadata, microservice, moduleName) {
+    this.moduleInstance = moduleInstance;
+    this.actionName = actionName;
+    this.metadata = metadata;
+    this.microservice = microservice;
+    this.moduleName = moduleName;
+  }
+  async handle(req) {
+    const span = tracer.startSpan("handle");
+    span.addEvent("logs");
+    logger2.emit({
+      attributes: { module: this.moduleName, action: this.actionName }
+    });
+    const startTime = Date.now();
+    let args;
+    if (typeof req === "string") {
+      try {
+        args = Object.values(ejson3__default.default.parse(req));
+      } catch (error) {
+        throw new Error(`Invalid request body: ${error.message}`);
+      }
+    } else {
+      args = req;
+    }
+    if (this.metadata.params) {
+      args = args.map((arg, index) => {
+        try {
+          return this.metadata.params[index].parse(arg);
+        } catch (error) {
+          throw new Error(
+            `Invalid argument ${index}: ${error.message}`
+          );
+        }
+      });
+    }
+    const requestHash = hashText(ejson3__default.default.stringify(args));
+    if (!this.metadata.stream && this.metadata.cache && !this.microservice.options.disableCache) {
+      const cacheKey = `${this.moduleName}.${this.actionName}.${requestHash}`;
+      const cached = await this.microservice.cache.get(cacheKey);
+      const now = Date.now();
+      if (cached.value !== null && (!this.metadata.ttl || cached.value?.expireAt > now)) {
+        this.microservice.updateMethodStats(
+          this.moduleName,
+          this.actionName,
+          0,
+          true,
+          true
+        );
+        return cached.value.data;
+      }
+    }
+    try {
+      const result = await this.moduleInstance[this.actionName].apply(
+        this.moduleInstance,
+        args
+      );
+      if (this.metadata.stream) {
+        if (!isAsyncIterable(result)) {
+          throw new Error("Stream action must return AsyncIterator");
+        }
+        let count = 0;
+        const self = this;
+        return {
+          [Symbol.asyncIterator]() {
+            const iterator = result[Symbol.asyncIterator]();
+            return {
+              async next() {
+                try {
+                  const { value, done } = await iterator.next();
+                  if (!done) count++;
+                  if (done) {
+                    const responseTime = Date.now() - startTime;
+                    self.microservice.updateMethodStats(
+                      self.moduleName,
+                      self.actionName,
+                      responseTime / count,
+                      true
+                    );
+                  }
+                  return { value, done };
+                } catch (error) {
+                  self.microservice.updateMethodStats(
+                    self.moduleName,
+                    self.actionName,
+                    0,
+                    false
+                  );
+                  throw error;
+                }
+              }
+            };
+          }
+        };
+      }
+      let parsedResult = result;
+      if (this.metadata.returns) {
+        try {
+          parsedResult = this.metadata.returns.parse(result);
+        } catch (error) {
+          throw new Error(`Invalid return value: ${error.message}`);
+        }
+      }
+      if (this.metadata.cache && !this.microservice.options.disableCache) {
+        const cacheKey = `${this.moduleName}.${this.actionName}.${requestHash}`;
+        const now = Date.now();
+        this.microservice.cache.set(cacheKey, {
+          data: parsedResult,
+          expireAt: this.metadata.ttl ? now + this.metadata.ttl : void 0
+        });
+      }
+      this.microservice.updateMethodStats(
+        this.moduleName,
+        this.actionName,
+        0,
+        true
+      );
+      return parsedResult;
+    } catch (error) {
+      if (this.metadata.printError !== false && this.microservice.options.printError !== false) {
+        console.error(`Error in ${this.moduleName}.${this.actionName}:`, error);
+      }
+      if (this.microservice.options.events?.onError) {
+        this.microservice.options.events.onError({
+          requestHash,
+          service: {
+            id: this.microservice.serviceId,
+            name: this.microservice.options.name,
+            version: this.microservice.options.version,
+            env: this.microservice.options.env
+          },
+          module: this.moduleName,
+          action: this.actionName,
+          params: args,
+          time: Date.now(),
+          error: error.message
+        });
+      }
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+};
+function isAsyncIterable(obj) {
+  return obj != null && typeof obj[Symbol.asyncIterator] === "function";
+}
+var WebSocketHandler = class {
+  constructor(microservice, options) {
+    this.microservice = microservice;
+    this.options = {
+      timeout: options?.timeout || 3e4
+    };
+  }
+  sockets = /* @__PURE__ */ new Set();
+  pendingRequests = /* @__PURE__ */ new Map();
+  options;
+  onOpen(ws) {
+    this.sockets.add(ws);
+  }
+  async encodeMessage(message) {
+    const jsonStr = ejson3__default.default.stringify(message);
+    const data = new TextEncoder().encode(jsonStr);
+    const compressed = await brotli.compress(data, 6);
+    return compressed;
+  }
+  async decodeMessage(data) {
+    try {
+      const decompressed = await brotli.decompress(new Uint8Array(data));
+      const jsonStr = new TextDecoder().decode(decompressed);
+      return ejson3__default.default.parse(jsonStr);
+    } catch (error) {
+      console.error("Error decoding message", error);
+      throw error;
+    }
+  }
+  async sendMessage(ws, message) {
+    const encoded = await this.encodeMessage(message);
+    ws.send(encoded);
+  }
+  async onMessage(event, ws) {
+    let messageId = "";
+    try {
+      const message = await this.decodeMessage(event.data);
+      messageId = message.id || "";
+      if (message.type === "ping") {
+        await this.sendMessage(ws, { type: "pong" });
+        return;
+      }
+      const response = await this.handleRequest(ws, message);
+      if (response) {
+        await this.sendMessage(ws, response);
+      }
+    } catch (error) {
+      if (messageId) {
+        await this.sendMessage(ws, {
+          id: messageId,
+          success: false,
+          error: error.message
+        });
+      }
+      console.error("Failed to handle WebSocket message:", error);
+    }
+  }
+  onClose(ws) {
+    this.sockets.delete(ws);
+    for (const [id, pending] of this.pendingRequests.entries()) {
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(id);
+      }
+    }
+  }
+  onError(_error, ws) {
+    this.onClose(ws);
+  }
+  async handleRequest(ws, message) {
+    if (!message.id || !message.module || !message.action) {
+      throw new Error("Invalid request message");
+    }
+    const timer = setTimeout(() => {
+      const pending = this.pendingRequests.get(message.id);
+      if (pending) {
+        this.pendingRequests.delete(message.id);
+        this.microservice.updateMethodStats(
+          pending.module,
+          pending.action,
+          0,
+          false
+        );
+        ws.send(
+          ejson3__default.default.stringify({
+            id: message.id,
+            success: false,
+            error: "Request timeout"
+          })
+        );
+      }
+    }, this.options.timeout);
+    this.pendingRequests.set(message.id, {
+      timer,
+      module: message.module,
+      action: message.action
+    });
+    return (async () => {
+      const startTime = Date.now();
+      try {
+        const handler = this.microservice.getActionHandler(
+          message.module,
+          message.action
+        );
+        const args = message.args ? Object.values(message.args) : [];
+        const result = await handler.handle(args);
+        if (handler.metadata.stream) {
+          try {
+            for await (const value of result) {
+              await this.sendMessage(ws, {
+                id: message.id,
+                type: "stream",
+                data: value,
+                done: false
+              });
+            }
+            await this.sendMessage(ws, {
+              id: message.id,
+              type: "stream",
+              done: true
+            });
+            return null;
+          } catch (error) {
+            throw error;
+          }
+        }
+        const responseTime = Date.now() - startTime;
+        this.microservice.updateMethodStats(
+          message.module,
+          message.action,
+          responseTime,
+          true
+        );
+        return {
+          id: message.id,
+          success: true,
+          data: result
+        };
+      } catch (error) {
+        this.microservice.updateMethodStats(
+          message.module,
+          message.action,
+          0,
+          false
+        );
+        return {
+          id: message.id,
+          success: false,
+          error: error.message
+        };
+      } finally {
+        const pending = this.pendingRequests.get(message.id);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingRequests.delete(message.id);
+        }
+      }
+    })();
+  }
+  close() {
+    for (const socket of this.sockets) {
+      socket.close();
+    }
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timer);
+    }
+    this.sockets.clear();
+    this.pendingRequests.clear();
+  }
+};
+
+// core/core.ts
+var ServiceContext = {};
+var Microservice = class {
+  app;
+  nodeWebSocket;
+  codeCache;
+  waitingInitialization;
+  etcdClient;
+  serviceKey;
+  statsMap = /* @__PURE__ */ new Map();
+  lease;
+  scheduler;
+  abortController;
+  isShuttingDown = false;
+  statisticsTimer;
+  wsHandler;
+  actionHandlers = /* @__PURE__ */ new Map();
+  modules = /* @__PURE__ */ new Map();
+  fetch;
+  options;
+  cache;
+  serviceId;
+  constructor(options) {
+    this.app = new hono.Hono();
+    this.nodeWebSocket = nodeWs.createNodeWebSocket({ app: this.app });
+    this.serviceId = crypto.randomUUID();
+    this.options = {
+      prefix: "/api",
+      name: "microservice",
+      ...options
+    };
+    this.fetch = this.app.request;
+    this.waitingInitialization = this.initialize();
+    ServiceContext.service = this;
+  }
+  async initialize() {
+    this.cache = new lruCache.LRUCache({
+      max: 1e3,
+      ttl: 1e3 * 60 * 10
+    });
+    if (this.options.etcd) {
+      this.initEtcd(this.options.etcd);
+    }
+    await this.initModules();
+    this.initRoutes();
+    this.initShutdownHandlers();
+    if (this.options.events?.onStats) {
+      this.initStatsEventManager();
+    }
+    await this.registerService(true);
+  }
+  async initModules() {
+    for (const ModuleClass of this.options.modules) {
+      const moduleInstance = new ModuleClass();
+      const metadata = getModuleMetadata(ModuleClass);
+      if (!metadata) {
+        throw new Error(
+          `Module ${ModuleClass.name} is not decorated with @Module`
+        );
+      }
+      const moduleName = metadata.name;
+      logger_default.info(`[ \u6CE8\u518C\u6A21\u5757 ] ${moduleName} ${metadata.options.description}`);
+      this.modules.set(moduleName, moduleInstance);
+      const actions = getActionMetadata(ModuleClass.prototype);
+      for (const [actionName, actionMetadata] of Object.entries(actions)) {
+        const handler = new ActionHandler(
+          moduleInstance,
+          actionName,
+          actionMetadata,
+          this,
+          moduleName
+        );
+        this.actionHandlers.set(`${moduleName}.${actionName}`, handler);
+        logger_default.info(
+          `[ \u6CE8\u518C\u52A8\u4F5C ] ${moduleName}.${actionName} ${actionMetadata.description}`
+        );
+      }
+      const schedules = getScheduleMetadata(ModuleClass.prototype);
+      if (schedules && Object.keys(schedules).length > 0) {
+        if (!this.scheduler && this.etcdClient) {
+          this.scheduler = new Scheduler(this.etcdClient);
+        }
+        for (const [methodName, metadata2] of Object.entries(schedules)) {
+          const electionKey = `${this.options.name}/${moduleName}/schedules/${metadata2.name}`;
+          this.scheduler.startSchedule(
+            this.serviceId,
+            moduleName,
+            methodName,
+            electionKey,
+            metadata2,
+            ModuleClass.prototype[methodName].bind(moduleInstance)
+          );
+          logger_default.info(
+            `[ \u542F\u52A8\u8C03\u5EA6\u4EFB\u52A1 ] ${moduleName}.${metadata2.name} interval = ${metadata2.interval} mode = ${metadata2.mode}`
+          );
+        }
+      }
+    }
+    if (this.options.generateClient) {
+      logger_default.info(`[ \u751F\u6210\u5BA2\u6237\u7AEF\u4EE3\u7801 ] ${this.options.generateClient}`);
+      await this.generateClientCode();
+    }
+  }
+  initRoutes() {
+    const startTime = Date.now();
+    const prefix = this.options.prefix || "/api";
+    this.app.get(prefix, (ctx) => {
+      const name = this.options.name ?? "Microservice";
+      const version = this.options.version ?? "1.0.0";
+      return ctx.text(`${name} is running. version: ${version}`);
+    });
+    this.app.get(`${prefix}/health`, (ctx) => {
+      return ctx.json({
+        status: "ok",
+        uptime: Date.now() - startTime,
+        timestamp: Date.now()
+      });
+    });
+    this.app.get(`${prefix}/status`, (ctx) => {
+      return ctx.json({
+        id: this.serviceId,
+        name: this.options.name,
+        version: this.options.version,
+        env: this.options.env,
+        modules: this.getModules(),
+        stats: Object.fromEntries(this.statsMap)
+      });
+    });
+    this.app.get(`${prefix}/client.ts`, async (ctx) => {
+      ctx.header("Content-Type", "application/typescript; charset=utf-8");
+      ctx.header("Content-Disposition", "attachment; filename=client.ts");
+      ctx.header("Cache-Control", "public, max-age=3600");
+      return ctx.body(await this.clientCode());
+    });
+    this.app.post(`${prefix}/:moduleName/:actionName`, this.handleRequest);
+    if (this.options.websocket?.enabled) {
+      this.wsHandler = new WebSocketHandler(this);
+      this.app.get(
+        `${prefix}/ws`,
+        this.nodeWebSocket.upgradeWebSocket((_ctx) => {
+          const wsHandler = new WebSocketHandler(this, {
+            timeout: this.options.websocket?.timeout
+          });
+          return {
+            onOpen(_event, ws) {
+              wsHandler.onOpen(ws);
+            },
+            onMessage(message, ws) {
+              wsHandler.onMessage(message, ws);
+            },
+            onClose(_evt, ws) {
+              wsHandler.onClose(ws);
+            },
+            onError(error, ws) {
+              wsHandler.onError(error, ws);
+            }
+          };
+        })
+      );
+    }
+  }
+  async generateClientCode() {
+    if (typeof this.options.generateClient === "string" || this.options.generateClient instanceof URL) {
+      const code = await this.clientCode();
+      await fs__default.default.writeFile(this.options.generateClient, code);
+    }
+  }
+  async clientCode() {
+    if (!this.codeCache) {
+      this.codeCache = await formatCode(
+        await generateClientCode(this.getModules(true))
+      );
+    }
+    return this.codeCache;
+  }
+  initEtcd(config) {
+    this.etcdClient = new etcd3.Etcd3({
+      hosts: config.hosts,
+      auth: config.auth
+    });
+    const serviceName = this.options.name || "microservice";
+    const namespace = config.namespace ? `${config.namespace}/` : "";
+    this.serviceKey = `${namespace}services/${serviceName}/${this.serviceId}`;
+    const ttl = config.ttl || 10;
+    this.lease = this.etcdClient.lease(ttl);
+    ServiceContext.lease = this.lease;
+    ServiceContext.etcdClient = this.etcdClient;
+  }
+  /**
+   * 注册服务
+   */
+  async registerService(update = false) {
+    const serviceInfo = {
+      id: this.serviceId,
+      name: this.options.name,
+      version: this.options.version,
+      prefix: this.options.prefix,
+      env: this.options.env,
+      modules: this.getModules(false)
+    };
+    if (update) {
+      await this.options.events?.onRegister?.(serviceInfo)?.catch((e) => {
+        logger_default.error(`Failed to emit register event: ${e}`);
+      });
+    }
+  }
+  /**
+   * 更新方法统计信息
+   */
+  updateMethodStats(moduleName, methodName, responseTime, success, cacheHit = false) {
+    const key = `${moduleName}.${methodName}`;
+    let stats = this.statsMap.get(key);
+    if (!stats) {
+      stats = {
+        totalCalls: 0,
+        successCalls: 0,
+        failureCalls: 0,
+        avgResponseTime: 0,
+        maxResponseTime: 0,
+        minResponseTime: Number.MAX_SAFE_INTEGER,
+        lastUpdateTime: Date.now(),
+        cacheHit: 0
+      };
+      this.statsMap.set(key, stats);
+    }
+    stats.totalCalls++;
+    if (success) {
+      stats.successCalls++;
+    } else {
+      stats.failureCalls++;
+    }
+    stats.avgResponseTime = (stats.avgResponseTime * (stats.totalCalls - 1) + responseTime) / stats.totalCalls;
+    stats.maxResponseTime = Math.max(stats.maxResponseTime, responseTime);
+    stats.minResponseTime = Math.min(stats.minResponseTime, responseTime);
+    stats.lastUpdateTime = Date.now();
+    stats.cacheHit += cacheHit ? 1 : 0;
+  }
+  /**
+   * 获取 Hono 应用实例
+   */
+  getApp() {
+    return this.app;
+  }
+  /**
+   * 启动服务
+   */
+  async start(port = 3e3, silent = false) {
+    await this.waitingInitialization;
+    const prefix = this.options.prefix ?? "/api";
+    this.abortController = new AbortController();
+    !silent && console.log("");
+    const server = nodeServer.serve({ fetch: this.app.fetch, port });
+    this.nodeWebSocket.injectWebSocket(server);
+    if (!silent) {
+      console.log(
+        `\u{1F680} Microservice is running on http://localhost:${port}${prefix}`
+      );
+      console.log(
+        `\u{1F4DA} Client SDK available at http://localhost:${port}${prefix}/client.ts`
+      );
+      this.options.websocket?.enabled && console.info(
+        `\u{1F517} WebSocket available at http://localhost:${port}${prefix}/ws`
+      );
+    }
+  }
+  /**
+   * 获取所有模块的元数据
+   */
+  getModules(withTypes = false) {
+    const modules = {};
+    for (const [moduleName, moduleInstance] of this.modules) {
+      const metadata = getModuleMetadata(moduleInstance.constructor);
+      if (!metadata) continue;
+      modules[moduleName] = {
+        name: metadata.name,
+        version: metadata.options.version,
+        description: metadata.options.description,
+        printError: metadata.options.printError,
+        actions: Object.fromEntries(
+          Array.from(this.actionHandlers.entries()).filter(([key]) => key.startsWith(moduleName + ".")).map(([key, handler]) => {
+            const metadata2 = { ...handler.metadata };
+            if (!withTypes) {
+              delete metadata2.params;
+              delete metadata2.returns;
+            }
+            return [key.slice(moduleName.length + 1), metadata2];
+          })
+        )
+      };
+    }
+    return modules;
+  }
+  /**
+   * 停止服务
+   */
+  async stop() {
+    if (this.wsHandler) {
+      this.wsHandler.close();
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    if (this.scheduler) {
+      await this.scheduler.stop();
+    }
+    if (this.options.events?.onStats && this.options.events.forceEmitOnShutdown) {
+      await this.updateStats().catch((e) => {
+        logger_default.error("Failed to emit final stats:", e);
+      });
+    }
+    if (this.etcdClient && this.serviceKey) {
+      await this.etcdClient.delete().key(this.serviceKey);
+      this.etcdClient.close();
+    }
+  }
+  /**
+   * 初始化停机处理
+   */
+  initShutdownHandlers() {
+    process.on("SIGINT", () => {
+      logger_default.info(`
+Received SIGINT signal`);
+      this.gracefulShutdown();
+    });
+    process.on("unhandledrejection", (event) => {
+      logger_default.error("Unhandled rejection:", event.reason);
+    });
+    process.on("error", (event) => {
+      logger_default.error("Uncaught error:", event.error);
+    });
+  }
+  /**
+   * 优雅停机
+   */
+  async gracefulShutdown() {
+    if (this.isShuttingDown) return;
+    this.isShuttingDown = true;
+    logger_default.info("\nGraceful shutdown initiated...");
+    if (this.statisticsTimer) clearInterval(this.statisticsTimer);
+    try {
+      await this.stop();
+      logger_default.info("Graceful shutdown completed");
+    } catch (error) {
+      logger_default.error("Error during shutdown:", error);
+      process.exit(1);
+    } finally {
+      process.exit(0);
+    }
+  }
+  initStatsEventManager() {
+    this.statisticsTimer = setInterval(async () => {
+      await this.updateStats();
+    }, this.options.events.interval ?? 1e4);
+  }
+  async updateStats() {
+    const now = Date.now();
+    const { onStats } = this.options.events;
+    this.registerService(true);
+    for (const [key, stats] of this.statsMap.entries()) {
+      if (stats) {
+        const [moduleName, actionName] = key.split(".");
+        try {
+          await onStats?.({
+            service: {
+              env: this.options.env,
+              id: this.serviceId,
+              name: this.options.name,
+              version: this.options.version
+            },
+            module: moduleName,
+            action: actionName,
+            stats,
+            startTime: stats.lastUpdateTime,
+            endTime: now
+          });
+          this.statsMap.delete(key);
+        } catch (error) {
+          logger_default.error(`Failed to emit stats event for ${key}:`, error);
+        }
+      }
+    }
+  }
+  getActionHandler(moduleName, actionName) {
+    const key = `${moduleName}.${actionName}`;
+    const handler = this.actionHandlers.get(key);
+    if (!handler) {
+      throw new Error(`Action ${actionName} not found in module ${moduleName}`);
+    }
+    return handler;
+  }
+  handleRequest = async (ctx) => {
+    const { moduleName, actionName } = ctx.req.param();
+    const handler = this.getActionHandler(moduleName, actionName);
+    try {
+      const paramsText = await ctx.req.text();
+      const result = await handler.handle(paramsText);
+      if (handler.metadata.stream) {
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+          async start(controller) {
+            try {
+              for await (const value of result) {
+                const response = { value, done: false };
+                const chunk = encoder.encode(ejson3__default.default.stringify(response) + "\n");
+                controller.enqueue(chunk);
+              }
+              controller.enqueue(
+                encoder.encode(
+                  ejson3__default.default.stringify({ done: true }) + "\n"
+                )
+              );
+              controller.close();
+            } catch (error) {
+              const response = {
+                error: error.message,
+                done: true
+              };
+              controller.enqueue(
+                encoder.encode(ejson3__default.default.stringify(response) + "\n")
+              );
+              controller.close();
+            }
+          }
+        });
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          }
+        });
+      }
+      return ctx.text(ejson3__default.default.stringify({ success: true, data: result }));
+    } catch (error) {
+      return ctx.json({ success: false, error: error.message });
+    }
+  };
+  async init() {
+    await this.waitingInitialization;
+  }
+  /**
+   * 获取所有注册的服务
+   */
+  async getServices() {
+    if (!this.etcdClient) {
+      throw new Error("etcd is not configured");
+    }
+    const namespace = this.options.etcd?.namespace ? `${this.options.etcd.namespace}/` : "";
+    const servicesKey = `${namespace}services`;
+    const services = await this.etcdClient.getAll().prefix(servicesKey);
+    return Object.values(services).map((value) => JSON.parse(value));
+  }
+  /**
+   * 获取指定服务的实例
+   */
+  async getServiceInstances(serviceName) {
+    if (!this.etcdClient) {
+      throw new Error("etcd is not configured");
+    }
+    const namespace = this.options.etcd?.namespace ? `${this.options.etcd.namespace}/` : "";
+    const serviceKey = `${namespace}services/${serviceName}`;
+    const instances = await this.etcdClient.getAll().prefix(serviceKey);
+    return Object.values(instances).map((value) => JSON.parse(value));
+  }
+};
+
+// utils/checker.ts
+async function startCheck(checkers, pass) {
+  logger_default.info("[ \u9884\u68C0\u5F00\u59CB ]");
+  for (const [index, checker] of checkers.entries()) {
+    const seq = index + 1;
+    logger_default.info(`${seq}. ${checker.name}`);
+    try {
+      if (checker.skip) {
+        logger_default.warn(`${seq}. ${checker.name} [\u8DF3\u8FC7]`);
+        continue;
+      }
+      await checker.check();
+      logger_default.info(`${seq}. ${checker.name} [\u6210\u529F]`);
+    } catch (error) {
+      logger_default.error(`${seq}. ${checker.name} [\u5931\u8D25]`);
+      throw error;
+    }
+  }
+  logger_default.info("[ \u9884\u68C0\u5B8C\u6210 ]");
+  if (pass) await pass();
+}
+
+Object.defineProperty(exports, "dayjs", {
+  enumerable: true,
+  get: function () { return dayjs__default.default; }
+});
+exports.Action = Action;
+exports.Microservice = Microservice;
+exports.Module = Module;
+exports.Schedule = Schedule;
+exports.ScheduleMode = ScheduleMode;
+exports.ServiceContext = ServiceContext;
+exports.logger = logger_default;
+exports.startCheck = startCheck;
+Object.keys(zod).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return zod[k]; }
+  });
+});