@simplysm/service-common 13.0.100 → 14.0.1

package/src/service-types/smtp-client-service.types.ts

@@ -1,41 +0,0 @@
-export interface SmtpClientSendAttachment {
-  filename: string;
-  content?: string | Uint8Array;
-  path?: any;
-  contentType?: string;
-}
-
-export interface SmtpClientSendByDefaultOption {
-  to: string;
-  cc?: string;
-  bcc?: string;
-  subject: string;
-  html: string;
-  attachments?: SmtpClientSendAttachment[];
-}
-
-export interface SmtpClientSendOption {
-  host: string;
-  port?: number;
-  secure?: boolean;
-  user?: string;
-  pass?: string;
-
-  from: string;
-  to: string;
-  cc?: string;
-  bcc?: string;
-  subject: string;
-  html: string;
-  attachments?: SmtpClientSendAttachment[];
-}
-
-export interface SmtpClientDefaultOptions {
-  senderName: string;
-  senderEmail?: string;
-  user?: string;
-  pass?: string;
-  host: string;
-  port?: number;
-  secure?: boolean;
-}

package/tests/define-event.spec.ts

@@ -1,11 +0,0 @@
-// packages/service-common/tests/define-event.spec.ts
-import { describe, it, expect } from "vitest";
-import { defineEvent } from "@simplysm/service-common";
-
-describe("defineEvent", () => {
-  it("create event definition with given name", () => {
-    const evt = defineEvent<{ channel: string }, string>("OrderUpdated");
-    expect(evt.eventName).toBe("OrderUpdated");
-  });
-
-});

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

@@ -1,251 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { createServiceProtocol, type ServiceProtocol } from "../../src/protocol/create-service-protocol";
-import type { ServiceMessage } from "../../src/protocol/protocol.types";
-import { Uuid } from "@simplysm/core-common";
-
-describe("ServiceProtocol", () => {
-  let protocol: ServiceProtocol;
-
-  beforeEach(() => {
-    protocol = createServiceProtocol();
-  });
-
-  afterEach(() => {
-    protocol.dispose();
-  });
-
-  describe("Encoding", () => {
-    it("encode single message", () => {
-      const uuid = Uuid.generate().toString();
-      const message: ServiceMessage = { name: "test.method", body: [{ test: "data" }] };
-
-      const result = protocol.encode(uuid, message);
-
-      expect(result.chunks.length).toBe(1);
-      expect(result.totalSize).toBeGreaterThan(0);
-    });
-
-    it("throw error when message exceeds 100MB", () => {
-      const uuid = Uuid.generate().toString();
-      // Generate data larger than 100MB
-      const largeData = "x".repeat(101 * 1024 * 1024);
-      const message: ServiceMessage = { name: "test.method", body: [largeData] };
-
-      expect(() => protocol.encode(uuid, message)).toThrow("Message size exceeds the limit.");
-    });
-  });
-
-  describe("Decoding", () => {
-    it("decode single message", () => {
-      const uuid = Uuid.generate().toString();
-      const message: ServiceMessage = { name: "test.method", body: [{ value: 123 }] };
-
-      const encoded = protocol.encode(uuid, message);
-      const result = protocol.decode(encoded.chunks[0]);
-
-      expect(result.type).toBe("complete");
-      if (result.type === "complete") {
-        expect(result.message.name).toBe("test.method");
-        expect(result.message.body).toEqual([{ value: 123 }]);
-      }
-    });
-
-    it("throw error when buffer size is smaller than header size", () => {
-      const smallBytes = new Uint8Array(20);
-
-      expect(() => protocol.decode(smallBytes)).toThrow("Buffer size is smaller than header size.");
-    });
-
-    it("throw error when decoded message exceeds 100MB", () => {
-      // Manually create header with totalSize exceeding 100MB
-      const headerBytes = new Uint8Array(28);
-      const uuidBytes = new Uuid(Uuid.generate().toString()).toBytes();
-      headerBytes.set(uuidBytes, 0);
-
-      const headerView = new DataView(
-        headerBytes.buffer,
-        headerBytes.byteOffset,
-        headerBytes.byteLength,
-      );
-      headerView.setBigUint64(16, BigInt(101 * 1024 * 1024), false); // 101MB
-      headerView.setUint32(24, 0, false);
-
-      expect(() => protocol.decode(headerBytes)).toThrow("Message size exceeds the limit.");
-    });
-  });
-
-  describe("Chunking", () => {
-    it("chunk message larger than 3MB", () => {
-      const uuid = Uuid.generate().toString();
-      // Create 4MB data
-      const largeData = "x".repeat(4 * 1024 * 1024);
-      const message: ServiceMessage = { name: "test.method", body: [largeData] };
-
-      const result = protocol.encode(uuid, message);
-
-      expect(result.chunks.length).toBeGreaterThan(1);
-    });
-
-    it("assemble chunked message in order", () => {
-      const uuid = Uuid.generate().toString();
-      // 4MB data
-      const largeData = "x".repeat(4 * 1024 * 1024);
-      const message: ServiceMessage = { name: "test.method", body: [largeData] };
-
-      const encoded = protocol.encode(uuid, message);
-      expect(encoded.chunks.length).toBeGreaterThan(1);
-
-      // Decode chunks in order
-      let result!: ReturnType<typeof protocol.decode>;
-      for (let i = 0; i < encoded.chunks.length; i++) {
-        result = protocol.decode(encoded.chunks[i]);
-        if (i < encoded.chunks.length - 1) {
-          expect(result.type).toBe("progress");
-        }
-      }
-
-      expect(result.type).toBe("complete");
-      if (result.type === "complete") {
-        expect(result.message.body).toEqual([largeData]);
-      }
-    });
-
-    it("assemble chunked message in reverse order", () => {
-      const uuid = Uuid.generate().toString();
-      // 4MB data
-      const largeData = "x".repeat(4 * 1024 * 1024);
-      const message: ServiceMessage = { name: "test.method", body: [largeData] };
-
-      const encoded = protocol.encode(uuid, message);
-      const reversedChunks = [...encoded.chunks].reverse();
-
-      // Decode in reverse order
-      let result!: ReturnType<typeof protocol.decode>;
-      for (let i = 0; i < reversedChunks.length; i++) {
-        result = protocol.decode(reversedChunks[i]);
-      }
-
-      // Should complete at the end
-      expect(result.type).toBe("complete");
-      if (result.type === "complete") {
-        expect(result.message.body).toEqual([largeData]);
-      }
-    });
-
-    it("prevent duplicate packets", () => {
-      const uuid = Uuid.generate().toString();
-      // 4MB data
-      const largeData = "x".repeat(4 * 1024 * 1024);
-      const message: ServiceMessage = { name: "test.method", body: [largeData] };
-
-      const encoded = protocol.encode(uuid, message);
-
-      // Send first chunk twice
-      protocol.decode(encoded.chunks[0]);
-      const result1 = protocol.decode(encoded.chunks[0]); // Duplicate
-
-      // Should be in progress state, and completedSize should not increase from duplicate
-      expect(result1.type).toBe("progress");
-
-      // Send remaining chunks
-      let result!: ReturnType<typeof protocol.decode>;
-      for (let i = 1; i < encoded.chunks.length; i++) {
-        result = protocol.decode(encoded.chunks[i]);
-      }
-
-      expect(result.type).toBe("complete");
-      if (result.type === "complete") {
-        expect(result.message.body).toEqual([largeData]);
-      }
-    });
-  });
-
-  describe("UUID interleaving", () => {
-    it("receive chunks from multiple UUIDs in interleaved order", () => {
-      const uuid1 = Uuid.generate().toString();
-      const uuid2 = Uuid.generate().toString();
-
-      // Each with 4MB data to trigger chunking
-      const largeData1 = "A".repeat(4 * 1024 * 1024);
-      const largeData2 = "B".repeat(4 * 1024 * 1024);
-      const message1: ServiceMessage = { name: "test.method1", body: [largeData1] };
-      const message2: ServiceMessage = { name: "test.method2", body: [largeData2] };
-
-      const encoded1 = protocol.encode(uuid1, message1);
-      const encoded2 = protocol.encode(uuid2, message2);
-
-      expect(encoded1.chunks.length).toBeGreaterThan(1);
-      expect(encoded2.chunks.length).toBeGreaterThan(1);
-
-      // Decode chunks in interleaved order (uuid1[0], uuid2[0], uuid1[1], uuid2[1], ...)
-      const maxChunks = Math.max(encoded1.chunks.length, encoded2.chunks.length);
-      let result1!: ReturnType<typeof protocol.decode>;
-      let result2!: ReturnType<typeof protocol.decode>;
-
-      for (let i = 0; i < maxChunks; i++) {
-        if (i < encoded1.chunks.length) {
-          result1 = protocol.decode(encoded1.chunks[i]);
-        }
-        if (i < encoded2.chunks.length) {
-          result2 = protocol.decode(encoded2.chunks[i]);
-        }
-      }
-
-      // Both messages should complete
-      expect(result1.type).toBe("complete");
-      expect(result2.type).toBe("complete");
-
-      if (result1.type === "complete" && result2.type === "complete") {
-        expect(result1.message.name).toBe("test.method1");
-        expect(result1.message.body).toEqual([largeData1]);
-        expect(result2.message.name).toBe("test.method2");
-        expect(result2.message.body).toEqual([largeData2]);
-      }
-    });
-
-  });
-
-  describe("Edge cases", () => {
-    it("handle null body", () => {
-      const uuid = Uuid.generate().toString();
-      const message: ServiceMessage = { name: "test.method", body: [null] };
-
-      const encoded = protocol.encode(uuid, message);
-      const decoded = protocol.decode(encoded.chunks[0]);
-
-      expect(decoded.type).toBe("complete");
-      if (decoded.type === "complete") {
-        // JsonConvert.stringify/parse converts null to undefined
-        expect(decoded.message.body).toEqual([undefined]);
-      }
-    });
-
-    it("handle message at exactly 3MB boundary", () => {
-      const uuid = Uuid.generate().toString();
-      // Exactly 3MB
-      const data = "x".repeat(3 * 1024 * 1024 - 50); // Account for some JSON overhead
-      const message: ServiceMessage = { name: "test.method", body: [data] };
-
-      const encoded = protocol.encode(uuid, message);
-      // Messages up to 3MB should not be chunked
-      expect(encoded.chunks.length).toBe(1);
-    });
-
-    it("include correct information in progress response", () => {
-      const uuid = Uuid.generate().toString();
-      const largeData = "x".repeat(4 * 1024 * 1024);
-      const message: ServiceMessage = { name: "test.method", body: [largeData] };
-
-      const encoded = protocol.encode(uuid, message);
-      const result = protocol.decode(encoded.chunks[0]);
-
-      expect(result.type).toBe("progress");
-      if (result.type === "progress") {
-        expect(result.uuid).toBe(uuid);
-        expect(result.totalSize).toBe(encoded.totalSize);
-        expect(result.completedSize).toBeGreaterThan(0);
-        expect(result.completedSize).toBeLessThan(result.totalSize);
-      }
-    });
-  });
-});