imean-service-engine 2.0.0 → 2.0.2

package/src/plugins/action/action-plugin.test.ts

@@ -1,660 +0,0 @@
-import * as ejson from "ejson";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { z } from "zod";
-import { Testing } from "../../core/testing";
-import { Action, ActionPlugin } from "./index";
-
-// 用户 Schema
-const UserSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  age: z.number().min(0).max(150),
-});
-
-type User = z.infer<typeof UserSchema>;
-
-/**
- * 解析 ejson 格式的响应
- */
-async function parseEjsonResponse(response: Response): Promise<any> {
-  const text = await response.text();
-  return ejson.parse(text);
-}
-
-describe("ActionPlugin", () => {
-  let engine: ReturnType<typeof Testing.createTestEngine>["engine"];
-  let Module: ReturnType<typeof Testing.createTestEngine>["Module"];
-
-  beforeEach(() => {
-    const testEngine = Testing.createTestEngine({
-      plugins: [new ActionPlugin()],
-    });
-    engine = testEngine.engine;
-    Module = testEngine.Module;
-  });
-
-  afterEach(async () => {
-    console.log("afterEach in action-plugin.test.ts");
-    if (engine) {
-      await engine.stop();
-    }
-  });
-
-  it("应该能够使用Action装饰器装饰方法", async () => {
-    const users = new Map<string, User>();
-
-    @Module("user-service")
-    class UserService {
-      @Action({
-        description: "创建新用户",
-        params: [z.string(), z.number().min(0).max(150)],
-        returns: UserSchema,
-      })
-      createUser(name: string, age: number): User {
-        const id = (users.size + 1).toString();
-        const newUser = { id, name, age };
-        users.set(id, newUser);
-        return newUser;
-      }
-    }
-
-    await engine.start();
-
-    // 测试请求（新路由模式：引擎prefix + 模块名 + Handler名）
-    const response = await fetch(
-      `http://localhost:${engine.getPort()}/user-service/createUser`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/ejson" },
-        body: ejson.stringify({ "0": "Alice", "1": 25 }),
-      }
-    );
-
-    expect(response.status).toBe(200);
-    const result = await parseEjsonResponse(response);
-    expect(result).toMatchObject({
-      success: true,
-      data: {
-        id: expect.any(String),
-        name: "Alice",
-        age: 25,
-      },
-    });
-  });
-
-  it("应该校验参数类型", async () => {
-    @Module("test-service")
-    class TestService {
-      @Action({
-        params: [z.string(), z.number()],
-      })
-      testMethod(name: string, age: number): { name: string; age: number } {
-        return { name, age };
-      }
-    }
-
-    await engine.start();
-
-    // 测试无效参数（新路由模式：引擎prefix + 模块名 + Handler名）
-    const response = await fetch(
-      `http://localhost:${engine.getPort()}/test-service/testMethod`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/ejson" },
-        body: ejson.stringify({ "0": "Alice", "1": "invalid" }),
-      }
-    );
-
-    expect(response.status).toBe(400);
-    const error = (await parseEjsonResponse(response)) as {
-      success: boolean;
-      error: string;
-    };
-    expect(error.success).toBe(false);
-    expect(error.error).toContain("Validation failed");
-  });
-
-  it("应该支持可空参数", async () => {
-    @Module("test-service")
-    class TestService {
-      @Action({
-        params: [z.string(), z.number().optional(), z.string().optional()],
-      })
-      testMethod(
-        name: string,
-        age?: number,
-        email?: string
-      ): { name: string; age?: number; email?: string } {
-        return { name, age, email };
-      }
-    }
-
-    await engine.start();
-
-    // 测试只传递第一个参数（可空参数被忽略）（新路由模式：引擎prefix + 模块名 + Handler名）
-    const response = await fetch(
-      `http://localhost:${engine.getPort()}/test-service/testMethod`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/ejson" },
-        body: ejson.stringify({ "0": "Alice" }),
-      }
-    );
-
-    expect(response.status).toBe(200);
-    const result = (await response.json()) as {
-      success: boolean;
-      data: {
-        name: string;
-        age?: number;
-        email?: string;
-      };
-    };
-    expect(result.success).toBe(true);
-    expect(result.data.name).toBe("Alice");
-    // 可空参数可能不会出现在结果中（取决于实现）
-    expect(result.data.age).toBeUndefined();
-    expect(result.data.email).toBeUndefined();
-  });
-
-  it("应该支持参数对齐（跳过中间参数）", async () => {
-    @Module("test-service")
-    class TestService {
-      @Action({
-        params: [
-          z.string(),
-          z.number().optional(),
-          z.string().optional(),
-          z.boolean(),
-        ],
-      })
-      testMethod(
-        name: string,
-        age?: number,
-        email?: string,
-        active: boolean = false
-      ): { name: string; age?: number; email?: string; active: boolean } {
-        return { name, age, email, active };
-      }
-    }
-
-    await engine.start();
-
-    // 测试跳过中间参数，只传递第一个和最后一个（新路由模式：引擎prefix + 模块名 + Handler名）
-    const response = await fetch(
-      `http://localhost:${engine.getPort()}/test-service/testMethod`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/ejson" },
-        body: ejson.stringify({ "0": "Alice", "3": true }),
-      }
-    );
-
-    expect(response.status).toBe(200);
-    const result = await parseEjsonResponse(response);
-    expect(result).toMatchObject({
-      success: true,
-      data: {
-        name: "Alice",
-        active: true,
-      },
-    });
-  });
-
-  it("应该校验返回值", async () => {
-    @Module("test-service")
-    class TestService {
-      @Action({
-        params: [z.string(), z.number()],
-        returns: UserSchema,
-      })
-      createUser(name: string, age: number): any {
-        // 返回不符合 schema 的数据
-        return { invalid: "data" };
-      }
-    }
-
-    await engine.start();
-
-    const response = await fetch(
-      `http://localhost:${engine.getPort()}/test-service/createUser`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/ejson" },
-        body: ejson.stringify({ "0": "Alice", "1": 25 }),
-      }
-    );
-
-    expect(response.status).toBe(400);
-    const error = (await parseEjsonResponse(response)) as {
-      success: boolean;
-      error: string;
-    };
-    expect(error.success).toBe(false);
-    expect(error.error).toContain("Return value validation failed");
-  });
-
-  it("应该同时支持GET和POST方法", async () => {
-    @Module("test-service")
-    class TestService {
-      @Action({
-        params: [z.string()],
-      })
-      testMethod(name: string): { name: string } {
-        return { name };
-      }
-    }
-
-    await engine.start();
-
-    // 测试 GET 请求（从 query 参数解析）
-    const getResponse = await fetch(
-      `http://localhost:${engine.getPort()}/test-service/testMethod?0=Alice`
-    );
-
-    expect(getResponse.status).toBe(200);
-    const getResult = await parseEjsonResponse(getResponse);
-    expect(getResult).toMatchObject({
-      success: true,
-      data: { name: "Alice" },
-    });
-
-    // 测试 POST 请求（从 body 解析）
-    const postResponse = await fetch(
-      `http://localhost:${engine.getPort()}/test-service/testMethod`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/ejson" },
-        body: ejson.stringify({ "0": "Bob" }),
-      }
-    );
-
-    expect(postResponse.status).toBe(200);
-    const postResult = await parseEjsonResponse(postResponse);
-    expect(postResult).toMatchObject({
-      success: true,
-      data: { name: "Bob" },
-    });
-  });
-
-  it("应该支持引擎prefix", async () => {
-    // 创建带prefix的引擎
-    const { engine: engineWithPrefix, Module: ModuleWithPrefix } =
-        Testing.createTestEngine({
-        plugins: [new ActionPlugin()],
-        options: {
-          name: "test-service",
-          version: "1.0.0",
-          prefix: "/api",
-        },
-      });
-
-    @ModuleWithPrefix("test-service")
-    class TestService {
-      @Action({
-        params: [z.string()],
-      })
-      testMethod(name: string): { name: string } {
-        return { name };
-      }
-    }
-
-    const port = await engineWithPrefix.start();
-
-    // GET 请求从 query 参数解析（新路由模式：引擎prefix + 模块名 + Handler名）
-    const response = await fetch(
-      `http://localhost:${port}/api/test-service/testMethod?0=Alice`
-    );
-
-    expect(response.status).toBe(200);
-    const result = await parseEjsonResponse(response);
-    expect(result).toMatchObject({
-      success: true,
-      data: { name: "Alice" },
-    });
-  });
-
-  describe("错误处理和嵌套类型", () => {
-    it("应该正确处理嵌套对象的参数验证错误", async () => {
-      const AddressSchema = z.object({
-        street: z.string(),
-        city: z.string(),
-        zipCode: z.string().regex(/^\d{5}$/),
-      });
-
-      const UserWithAddressSchema = z.object({
-        name: z.string(),
-        age: z.number(),
-        address: AddressSchema,
-      });
-
-      @Module("test-service")
-      class TestService {
-        @Action({
-          params: [UserWithAddressSchema],
-        })
-        createUserWithAddress(user: z.infer<typeof UserWithAddressSchema>) {
-          return user;
-        }
-      }
-
-      await engine.start();
-
-      // 测试嵌套对象中缺少必需字段
-      const response1 = await fetch(
-        `http://localhost:${engine.getPort()}/test-service/createUserWithAddress`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/ejson" },
-          body: ejson.stringify({
-            "0": {
-              name: "Alice",
-              age: 25,
-              address: {
-                street: "123 Main St",
-                // 缺少 city 和 zipCode
-              },
-            },
-          }),
-        }
-      );
-
-      expect(response1.status).toBe(400);
-      const error1 = (await response1.json()) as {
-        success: boolean;
-        error: string;
-      };
-      expect(error1.success).toBe(false);
-      expect(error1.error).toContain("Validation failed");
-      expect(error1.error).toContain("参数[0]");
-      expect(error1.error).toContain("address.city");
-      expect(error1.error).toContain("address.zipCode");
-
-      // 测试嵌套对象中类型错误
-      const response2 = await fetch(
-        `http://localhost:${engine.getPort()}/test-service/createUserWithAddress`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/ejson" },
-          body: ejson.stringify({
-            "0": {
-              name: "Alice",
-              age: "invalid", // 类型错误
-              address: {
-                street: "123 Main St",
-                city: "New York",
-                zipCode: "12345",
-              },
-            },
-          }),
-        }
-      );
-
-      expect(response2.status).toBe(400);
-      const error2 = (await response2.json()) as {
-        success: boolean;
-        error: string;
-      };
-      expect(error2.success).toBe(false);
-      expect(error2.error).toContain("参数[0].age");
-    });
-
-    it("应该正确处理嵌套数组的参数验证错误", async () => {
-      const ItemSchema = z.object({
-        id: z.string(),
-        quantity: z.number().min(1),
-        price: z.number().positive(),
-      });
-
-      const OrderSchema = z.object({
-        orderId: z.string(),
-        items: z.array(ItemSchema),
-        total: z.number(),
-      });
-
-      @Module("test-service")
-      class TestService {
-        @Action({
-          params: [OrderSchema],
-        })
-        createOrder(order: z.infer<typeof OrderSchema>) {
-          return order;
-        }
-      }
-
-      const port = await engine.start();
-
-      // 测试嵌套数组中对象的验证错误
-      const response = await fetch(
-        `http://localhost:${port}/test-service/createOrder`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/ejson" },
-          body: ejson.stringify({
-            "0": {
-              orderId: "ORD-001",
-              items: [
-                {
-                  id: "ITEM-1",
-                  quantity: -1, // 无效：应该 >= 1
-                  price: 10.5,
-                },
-                {
-                  id: "ITEM-2",
-                  quantity: 2,
-                  price: -5, // 无效：应该是正数
-                },
-              ],
-              total: 100,
-            },
-          }),
-        }
-      );
-
-      expect(response.status).toBe(400);
-      const error = (await parseEjsonResponse(response)) as {
-        success: boolean;
-        error: string;
-      };
-      expect(error.success).toBe(false);
-      expect(error.error).toContain("Validation failed");
-      expect(error.error).toContain("参数[0]");
-      // 应该包含嵌套路径（items数组中的错误）
-      expect(error.error).toMatch(/items|quantity|price/);
-    });
-
-    it("应该正确处理深层嵌套对象的错误", async () => {
-      const CompanySchema = z.object({
-        name: z.string(),
-        employees: z.array(
-          z.object({
-            id: z.string(),
-            name: z.string(),
-            department: z.object({
-              name: z.string(),
-              location: z.object({
-                city: z.string(),
-                country: z.string(),
-              }),
-            }),
-          })
-        ),
-      });
-
-      @Module("test-service")
-      class TestService {
-        @Action({
-          params: [CompanySchema],
-        })
-        createCompany(company: z.infer<typeof CompanySchema>) {
-          return company;
-        }
-      }
-
-      const port = await engine.start();
-
-      // 测试深层嵌套错误 - 确保对象存在，但嵌套属性有类型错误
-      const response = await fetch(
-        `http://localhost:${port}/test-service/createCompany`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/ejson" },
-          body: ejson.stringify({
-            "0": {
-              name: "Acme Corp",
-              employees: [
-                {
-                  id: "EMP-1",
-                  name: "John",
-                  department: {
-                    name: "Engineering",
-                    location: {
-                      city: "New York",
-                      country: 123, // 类型错误：应该是字符串
-                    },
-                  },
-                },
-              ],
-            },
-          }),
-        }
-      );
-
-      expect(response.status).toBe(400);
-      const error = (await parseEjsonResponse(response)) as {
-        success: boolean;
-        error: string;
-      };
-      expect(error.success).toBe(false);
-      expect(error.error).toContain("Validation failed");
-      expect(error.error).toContain("参数[0]");
-      // 应该显示深层嵌套路径
-      expect(error.error).toMatch(/employees|department|location|country/);
-    });
-
-    it("应该正确处理返回值嵌套对象的验证错误", async () => {
-      const ProductSchema = z.object({
-        id: z.string(),
-        name: z.string(),
-        price: z.number().positive(),
-        category: z.object({
-          id: z.string(),
-          name: z.string(),
-        }),
-      });
-
-      @Module("test-service")
-      class TestService {
-        @Action({
-          params: [z.string()],
-          returns: ProductSchema,
-        })
-        getProduct(id: string): any {
-          // 返回不符合 schema 的嵌套数据
-          return {
-            id: "PROD-1",
-            name: "Test Product",
-            price: 100,
-            category: {
-              id: "CAT-1",
-              // 缺少 name
-            },
-          };
-        }
-      }
-
-      const port = await engine.start();
-
-      const response = await fetch(
-        `http://localhost:${port}/test-service/getProduct`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/ejson" },
-          body: ejson.stringify({ "0": "PROD-1" }),
-        }
-      );
-
-      expect(response.status).toBe(400);
-      const error = (await parseEjsonResponse(response)) as {
-        success: boolean;
-        error: string;
-      };
-      expect(error.success).toBe(false);
-      expect(error.error).toContain("Return value validation failed");
-      expect(error.error).toContain("category.name");
-    });
-
-    it("应该正确处理多个参数的嵌套错误", async () => {
-      const UserSchema = z.object({
-        name: z.string(),
-        profile: z.object({
-          email: z.string().email(),
-          age: z.number(),
-        }),
-      });
-
-      const OrderSchema = z.object({
-        orderId: z.string(),
-        items: z.array(
-          z.object({
-            productId: z.string(),
-            quantity: z.number(),
-          })
-        ),
-      });
-
-      @Module("test-service")
-      class TestService {
-        @Action({
-          params: [UserSchema, OrderSchema],
-        })
-        processOrder(
-          user: z.infer<typeof UserSchema>,
-          order: z.infer<typeof OrderSchema>
-        ) {
-          return { user, order };
-        }
-      }
-
-      const port = await engine.start();
-
-      // 测试多个参数都有嵌套错误
-      const response = await fetch(
-        `http://localhost:${port}/test-service/processOrder`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/ejson" },
-          body: ejson.stringify({
-            "0": {
-              name: "Alice",
-              profile: {
-                email: "invalid-email", // 无效邮箱
-                age: 25,
-              },
-            },
-            "1": {
-              orderId: "ORD-001",
-              items: [
-                {
-                  productId: "PROD-1",
-                  quantity: "invalid", // 类型错误
-                },
-              ],
-            },
-          }),
-        }
-      );
-
-      expect(response.status).toBe(400);
-      const error = (await parseEjsonResponse(response)) as {
-        success: boolean;
-        error: string;
-      };
-      expect(error.success).toBe(false);
-      expect(error.error).toContain("Validation failed");
-      // 应该包含两个参数的错误
-      expect(error.error).toContain("参数[0]");
-      expect(error.error).toContain("参数[1]");
-    });
-  });
-});

package/src/plugins/action/decorator.ts

@@ -1,14 +0,0 @@
-import { Handler } from "../../core/decorators";
-import { ActionOptions } from "./types";
-
-/**
- * Action装饰器（Handler的语法糖封装）
- * 固定type="action"，用于标注动作处理方法
- */
-export function Action(options: ActionOptions) {
-  return Handler({
-    type: "action",
-    options,
-  });
-}
-

package/src/plugins/action/index.ts

@@ -1,4 +0,0 @@
-export { ActionPlugin } from "./plugin";
-export { Action } from "./decorator";
-export type { ActionModuleOptions, ActionOptions } from "./types";
-