imean-service-engine 2.0.0 → 2.0.2

package/src/plugins/schedule/types.ts

@@ -1,94 +0,0 @@
-/**
- * 调度模式
- */
-export enum ScheduleMode {
-  /**
-   * 固定频率模式：无论任务执行时间多长，都会按照固定间隔执行
-   * 例如：每 5 秒执行一次，即使上次任务执行了 10 秒
-   */
-  FIXED_RATE = "FIXED_RATE",
-
-  /**
-   * 固定延迟模式：任务执行完成后，等待固定间隔再执行下一次
-   * 例如：任务执行了 10 秒，间隔 5 秒，则下次执行在 15 秒后
-   */
-  FIXED_DELAY = "FIXED_DELAY",
-}
-
-/**
- * 调度选项
- */
-export interface ScheduleOptions {
-  /**
-   * 执行间隔（毫秒）
-   */
-  interval: number;
-
-  /**
-   * 调度模式（默认 FIXED_RATE）
-   */
-  mode?: ScheduleMode;
-}
-
-/**
- * 调度元数据
- */
-export interface ScheduleMetadata {
-  /**
-   * 方法名称
-   */
-  name: string;
-
-  /**
-   * 执行间隔（毫秒）
-   */
-  interval: number;
-
-  /**
-   * 调度模式
-   */
-  mode: ScheduleMode;
-}
-
-/**
- * SchedulePlugin 配置选项
- */
-export interface SchedulePluginOptions {
-  /**
-   * Etcd3 客户端实例
-   * 如果未提供且 useMockEtcd 为 false，插件将不会启动调度任务
-   */
-  etcdClient?: Etcd3;
-
-  /**
-   * 是否使用 Mock Etcd（用于测试和本地开发）
-   * 当设置为 true 时，将使用内置的 MockEtcd3，始终选举自己作为 leader
-   * 这样可以在没有真实 etcd 的情况下运行调度任务
-   * 
-   * @default false
-   */
-  useMockEtcd?: boolean;
-}
-
-/**
- * Etcd3 类型定义（避免直接依赖 etcd3 包）
- */
-export interface Etcd3 {
-  election(key: string, ttl: number): Election;
-}
-
-export interface Election {
-  observe(): Promise<Observer>;
-  campaign(candidate: string): Campaign;
-}
-
-export interface Observer {
-  on(event: "change", callback: (leader: string) => void): void;
-}
-
-export interface Campaign {
-  on(event: "error", callback: (error: any) => void): void;
-  on(event: "elected", callback: () => void): void;
-  resign(): Promise<void>;
-}
-

package/src/plugins/schedule/utils.test.ts

@@ -1,163 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { HandlerMetadata } from "../../core/types";
-import { ScheduleMode } from "./types";
-import { extractScheduleMetadata } from "./utils";
-
-describe("extractScheduleMetadata", () => {
-  it("应该从 HandlerMetadata 中提取调度元数据", () => {
-    class TestModule {}
-
-    const handlers: HandlerMetadata[] = [
-      {
-        type: "schedule",
-        options: {
-          interval: 5000,
-          mode: ScheduleMode.FIXED_RATE,
-        },
-        method: function task1() {},
-        methodName: "task1",
-        module: TestModule,
-        wrap: () => {},
-      },
-      {
-        type: "schedule",
-        options: {
-          interval: 10000,
-          mode: ScheduleMode.FIXED_DELAY,
-        },
-        method: function task2() {},
-        methodName: "task2",
-        module: TestModule,
-        wrap: () => {},
-      },
-      {
-        type: "action", // 非 schedule 类型，应该被忽略
-        options: {},
-        method: function action1() {},
-        methodName: "action1",
-        module: TestModule,
-        wrap: () => {},
-      },
-    ];
-
-    const result = extractScheduleMetadata(handlers);
-
-    expect(result.size).toBe(1);
-    expect(result.has(TestModule)).toBe(true);
-
-    const moduleMetadata = result.get(TestModule)!;
-    expect(moduleMetadata.size).toBe(2);
-    expect(moduleMetadata.has("task1")).toBe(true);
-    expect(moduleMetadata.has("task2")).toBe(true);
-
-    const task1Metadata = moduleMetadata.get("task1")!;
-    expect(task1Metadata.name).toBe("task1");
-    expect(task1Metadata.interval).toBe(5000);
-    expect(task1Metadata.mode).toBe(ScheduleMode.FIXED_RATE);
-
-    const task2Metadata = moduleMetadata.get("task2")!;
-    expect(task2Metadata.name).toBe("task2");
-    expect(task2Metadata.interval).toBe(10000);
-    expect(task2Metadata.mode).toBe(ScheduleMode.FIXED_DELAY);
-  });
-
-  it("应该处理多个模块的调度任务", () => {
-    class Module1 {}
-    class Module2 {}
-
-    const handlers: HandlerMetadata[] = [
-      {
-        type: "schedule",
-        options: {
-          interval: 5000,
-          mode: ScheduleMode.FIXED_RATE,
-        },
-        method: function task1() {},
-        methodName: "task1",
-        module: Module1,
-        wrap: () => {},
-      },
-      {
-        type: "schedule",
-        options: {
-          interval: 10000,
-          mode: ScheduleMode.FIXED_DELAY,
-        },
-        method: function task2() {},
-        methodName: "task2",
-        module: Module2,
-        wrap: () => {},
-      },
-    ];
-
-    const result = extractScheduleMetadata(handlers);
-
-    expect(result.size).toBe(2);
-    expect(result.has(Module1)).toBe(true);
-    expect(result.has(Module2)).toBe(true);
-
-    const module1Metadata = result.get(Module1)!;
-    expect(module1Metadata.size).toBe(1);
-    expect(module1Metadata.has("task1")).toBe(true);
-
-    const module2Metadata = result.get(Module2)!;
-    expect(module2Metadata.size).toBe(1);
-    expect(module2Metadata.has("task2")).toBe(true);
-  });
-
-  it("应该使用默认的 FIXED_RATE 模式", () => {
-    class TestModule {}
-
-    const handlers: HandlerMetadata[] = [
-      {
-        type: "schedule",
-        options: {
-          interval: 5000,
-          // 不指定 mode
-        },
-        method: function task1() {},
-        methodName: "task1",
-        module: TestModule,
-        wrap: () => {},
-      },
-    ];
-
-    const result = extractScheduleMetadata(handlers);
-
-    const moduleMetadata = result.get(TestModule)!;
-    const taskMetadata = moduleMetadata.get("task1")!;
-    expect(taskMetadata.mode).toBe(ScheduleMode.FIXED_RATE);
-  });
-
-  it("应该处理空的 handlers 数组", () => {
-    const result = extractScheduleMetadata([]);
-    expect(result.size).toBe(0);
-  });
-
-  it("应该忽略非 schedule 类型的 handlers", () => {
-    class TestModule {}
-
-    const handlers: HandlerMetadata[] = [
-      {
-        type: "action",
-        options: {},
-        method: function action1() {},
-        methodName: "action1",
-        module: TestModule,
-        wrap: () => {},
-      },
-      {
-        type: "cache",
-        options: {},
-        method: function cache1() {},
-        methodName: "cache1",
-        module: TestModule,
-        wrap: () => {},
-      },
-    ];
-
-    const result = extractScheduleMetadata(handlers);
-    expect(result.size).toBe(0);
-  });
-});
-

package/src/plugins/schedule/utils.ts

@@ -1,41 +0,0 @@
-import { HandlerMetadata } from "../../core/types";
-import { ScheduleMetadata, ScheduleMode } from "./types";
-
-/**
- * 从 HandlerMetadata 中提取调度元数据
- * @param handlers Handler 元数据数组
- * @returns 调度元数据映射（模块类 -> 方法名 -> 元数据）
- */
-export function extractScheduleMetadata(
-  handlers: HandlerMetadata[]
-): Map<any, Map<string, ScheduleMetadata>> {
-  const result = new Map<any, Map<string, ScheduleMetadata>>();
-
-  // 筛选出所有 type="schedule" 的 handlers
-  const scheduleHandlers = handlers.filter(
-    (handler) => handler.type === "schedule"
-  );
-
-  for (const handler of scheduleHandlers) {
-    const moduleClass = handler.module;
-    const methodName = handler.methodName;
-    const options = handler.options || {};
-
-    // 获取或创建模块的元数据映射
-    if (!result.has(moduleClass)) {
-      result.set(moduleClass, new Map());
-    }
-
-    const moduleMetadata = result.get(moduleClass)!;
-
-    // 添加方法元数据
-    moduleMetadata.set(methodName, {
-      name: methodName,
-      interval: options.interval,
-      mode: (options.mode as ScheduleMode) || ScheduleMode.FIXED_RATE,
-    });
-  }
-
-  return result;
-}
-

package/tests/integration/client.test.ts

@@ -1,203 +0,0 @@
-/**
- * 集成测试：验证 Action、ClientCode、Cache 等插件的集成
- * 以及 MicroserviceClient 的功能（重试、错误处理等）
- */
-
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { engine, resetCounters } from "./dev-service";
-
-// 等待服务启动
-let client: any;
-
-beforeAll(async () => {
-  // 启动服务
-  await engine.start();
-  const port = engine.getPort();
-
-  // 等待客户端代码生成完成
-  await new Promise((resolve) => setTimeout(resolve, 500));
-
-  // 动态导入生成的客户端代码
-  const clientModule = await import("./generated/client");
-  const { MicroserviceClient: GeneratedClient } = clientModule;
-
-  // 创建客户端实例
-  client = new GeneratedClient({
-    baseUrl: `http://127.0.0.1:${port}`,
-    prefix: "/api",
-    // 测试重试，所有的错误都重试
-    retry: { shouldRetry: () => true },
-  });
-});
-
-beforeEach(() => {
-  resetCounters();
-});
-
-afterAll(async () => {
-  await engine.stop();
-});
-
-describe("HTTP Client Integration Test", () => {
-  // 测试获取用户
-  it("should get user successfully", async () => {
-    const user = await client.tests.getUser("1");
-    expect(user).toEqual({ id: "1", name: "张三", age: 25 });
-  });
-
-  // 测试获取不存在的用户
-  it("should handle user not found error", async () => {
-    try {
-      await client.tests.getUser("999");
-      throw new Error("应该抛出错误");
-    } catch (error: any) {
-      expect(error.message).toEqual("用户不存在");
-    }
-  });
-
-  // 测试参数校验
-  it("should check params type", async () => {
-    try {
-      await client.tests.getUser(1 as unknown as string);
-      throw new Error("应该抛出错误");
-    } catch (error: any) {
-      // Zod 4.x: 错误消息格式可能已变更，检查是否包含 "string" 或 "expected"
-      expect(
-        error.message.includes("Expected string") ||
-        error.message.includes("expected string") ||
-        error.message.includes("string") ||
-        error.message.includes("Validation failed")
-      ).toBe(true);
-    }
-  });
-
-  // 测试返回值为 unknown 的操作
-  it("should return unknown type", async () => {
-    const reg = await client.tests.unknownReturnAction(new RegExp("test"));
-    expect(reg instanceof RegExp).toBe(true);
-  });
-
-  // 测试返回值为 Record<string, string> 的操作
-  it("should return record type", async () => {
-    const record = await client.tests.recordReturnAction([
-      { cells: { a: { value: "1" }, b: { value: "2" } } },
-    ]);
-    expect(record).toEqual([
-      { cells: { a: { value: "1" }, b: { value: "2" } } },
-    ]);
-  });
-
-  // 测试创建用户
-  it("should create user successfully", async () => {
-    const user = await client.tests.createUser("王五", 28);
-    expect(user.name).toEqual("王五");
-    expect(user.age).toEqual(28);
-  });
-
-  // 测试幂等方法的更新操作
-  it("should update user with idempotent operation", async () => {
-    const result = await client.tests.updateUser("1", "张三丰", 35);
-    expect(result.name).toEqual("张三丰");
-    expect(result.age).toEqual(35);
-
-    // 再次执行相同的更新应该得到相同的结果
-    const secondResult = await client.tests.updateUser("1", "张三丰", 35);
-    expect(secondResult).toEqual(result);
-  });
-
-  // 测试可重试操作最终成功的场景
-  it("should succeed after retries", async () => {
-    const result = await client.tests.retryableOperation("1");
-    expect(result.id).toEqual("1");
-  });
-
-  // 测试重试多次后仍然失败的场景
-  it("should fail after all retries", async () => {
-    try {
-      await client.tests.alwaysFailOperation("1");
-      throw new Error("应该抛出错误");
-    } catch (error: any) {
-      expect(error.message).toEqual("永久性错误");
-    }
-  });
-
-  it("upload file", async () => {
-    const buffer = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-    const result = await client.tests.uploadFile(buffer);
-    expect(result.length).toEqual(10);
-    expect(result).toEqual(new Uint8Array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0]));
-  });
-
-  it("test no params and no return", async () => {
-    const result = await client.tests.noReturnAction();
-    expect(result).toEqual(undefined);
-  });
-
-  it("test optional params", async () => {
-    const result = await client.tests.optionalParams("test", null);
-    expect(result).toEqual("test");
-  });
-
-  it("test cache fn", async () => {
-    let start = Date.now();
-    const result = await client.tests.cacheFn("test", "Tom");
-    expect(result).toEqual("test");
-    expect(Date.now() - start).toBeGreaterThan(1000);
-
-    start = Date.now();
-    const result2 = await client.tests.cacheFn("test", "Jerry");
-    expect(result2).toEqual("test");
-    expect(Date.now() - start).toBeLessThan(200);
-  });
-
-  it("test cache result", async () => {
-    let start = Date.now();
-    // 第一次请求，缓存未命中
-    let result = await client.tests.cacheResultAction("test");
-    expect(Date.now() - start).toBeGreaterThan(1000);
-    expect(result).toEqual("test");
-
-    start = Date.now();
-    // 第二次请求，缓存命中
-    result = await client.tests.cacheResultAction("test");
-    expect(Date.now() - start).toBeLessThan(200);
-    expect(result).toEqual("test");
-
-    start = Date.now();
-    // 第三次请求，未命中key
-    result = await client.tests.cacheResultAction("test2");
-    expect(Date.now() - start).toBeGreaterThan(1000);
-    expect(result).toEqual("test2");
-
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    start = Date.now();
-    // 第四次请求，缓存过期
-    result = await client.tests.cacheResultAction("test");
-    expect(Date.now() - start).toBeGreaterThanOrEqual(1000);
-    expect(result).toEqual("test");
-  });
-
-  it("test default param", async () => {
-    const result = await client.tests.defaultParamAction();
-    expect(result).toEqual("test-1");
-  });
-
-  it("test default return", async () => {
-    const result = await client.tests.defaultReturnAction();
-    expect(result).toEqual({ a: "test" });
-  });
-
-  it("test streaming return", async () => {
-    const iter = await client.tests.streamNumbers(5);
-    const result: number[] = [];
-    for await (const item of iter) {
-      result.push(item);
-    }
-    expect(result).toEqual([0, 1, 2, 3, 4]);
-  });
-
-  it("test request context injection", async () => {
-    const result = await client.tests.requestContextAction();
-    expect(result).toEqual("/api/tests/requestContextAction");
-  });
-});