@simplysm/service-common 13.0.74 → 13.0.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/service-common",
-  "version": "13.0.74",
+  "version": "13.0.76",
   "description": "Simplysm package - Service module (common)",
   "author": "simplysm",
   "license": "Apache-2.0",
@@ -19,7 +19,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@simplysm/core-common": "13.0.74",
-    "@simplysm/orm-common": "13.0.74"
+    "@simplysm/core-common": "13.0.76",
+    "@simplysm/orm-common": "13.0.76"
   }
 }

package/tests/define-event.spec.ts

@@ -8,14 +8,4 @@ describe("defineEvent", () => {
     expect(evt.eventName).toBe("OrderUpdated");
   });
 
-  it("can be used for type inference (checked at compile time)", () => {
-    const _evt = defineEvent<{ orderId: number }, { status: string }>("OrderUpdated");
-
-    // Type level verification — fails at compile time if incorrect
-    const info: typeof _evt.$info = { orderId: 123 };
-    const data: typeof _evt.$data = { status: "shipped" };
-
-    expect(info.orderId).toBe(123);
-    expect(data.status).toBe("shipped");
-  });
 });

package/tests/protocol/service-protocol.spec.ts

@@ -25,18 +25,6 @@ describe("ServiceProtocol", () => {
       expect(result.totalSize).toBeGreaterThan(0);
     });
 
-    it("encode message without body", () => {
-      const uuid = Uuid.new().toString();
-      const message: ServiceMessage = {
-        name: "reload",
-        body: { clientName: undefined, changedFileSet: new Set() },
-      };
-
-      const result = protocol.encode(uuid, message);
-
-      expect(result.chunks.length).toBe(1);
-    });
-
     it("throw error when message exceeds 100MB", () => {
       const uuid = Uuid.new().toString();
       // Generate data larger than 100MB
@@ -215,63 +203,9 @@ describe("ServiceProtocol", () => {
       }
     });
 
-    it("receive 3 UUIDs in random order", () => {
-      const uuids = [Uuid.new().toString(), Uuid.new().toString(), Uuid.new().toString()];
-      const data = [
-        "X".repeat(4 * 1024 * 1024),
-        "Y".repeat(4 * 1024 * 1024),
-        "Z".repeat(4 * 1024 * 1024),
-      ];
-      const messages: ServiceMessage[] = data.map((d, i) => ({
-        name: `test.method${i}`,
-        body: [d],
-      }));
-
-      const encodedList = uuids.map((uuid, i) => protocol.encode(uuid, messages[i]));
-
-      // Combine all chunks into one array
-      const allChunks: { uuid: string; chunk: Uint8Array; originalIndex: number }[] = [];
-      encodedList.forEach((encoded, msgIdx) => {
-        encoded.chunks.forEach((chunk, chunkIdx) => {
-          allChunks.push({ uuid: uuids[msgIdx], chunk, originalIndex: chunkIdx });
-        });
-      });
-
-      // Randomize order (use reverse instead of seed-based shuffle)
-      allChunks.reverse();
-
-      // Decode all chunks
-      const results: Map<string, ReturnType<typeof protocol.decode>> = new Map();
-      for (const { uuid, chunk } of allChunks) {
-        results.set(uuid, protocol.decode(chunk));
-      }
-
-      // Verify all messages completed
-      for (let i = 0; i < 3; i++) {
-        const result = results.get(uuids[i]);
-        expect(result?.type).toBe("complete");
-        if (result?.type === "complete") {
-          expect(result.message.name).toBe(`test.method${i}`);
-          expect(result.message.body).toEqual([data[i]]);
-        }
-      }
-    });
   });
 
   describe("Edge cases", () => {
-    it("handle empty body", () => {
-      const uuid = Uuid.new().toString();
-      const message: ServiceMessage = { name: "test.method", body: [""] };
-
-      const encoded = protocol.encode(uuid, message);
-      const decoded = protocol.decode(encoded.chunks[0]);
-
-      expect(decoded.type).toBe("complete");
-      if (decoded.type === "complete") {
-        expect(decoded.message.body).toEqual([""]);
-      }
-    });
-
     it("handle null body", () => {
       const uuid = Uuid.new().toString();
       const message: ServiceMessage = { name: "test.method", body: [null] };
@@ -286,25 +220,6 @@ describe("ServiceProtocol", () => {
       }
     });
 
-    it("serialize complex object", () => {
-      const uuid = Uuid.new().toString();
-      const complexData = {
-        array: [1, 2, 3],
-        nested: { deep: { value: "test" } },
-        date: new Date().toISOString(),
-        unicode: "Korean test 🚀",
-      };
-      const message: ServiceMessage = { name: "test.method", body: [complexData] };
-
-      const encoded = protocol.encode(uuid, message);
-      const decoded = protocol.decode(encoded.chunks[0]);
-
-      expect(decoded.type).toBe("complete");
-      if (decoded.type === "complete") {
-        expect(decoded.message.body).toEqual([complexData]);
-      }
-    });
-
     it("handle message at exactly 3MB boundary", () => {
       const uuid = Uuid.new().toString();
       // Exactly 3MB