@blokjs/trigger-grpc 0.6.18 → 0.6.20

package/__tests__/unit/GrpcClient.test.ts

@@ -1,138 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-// vi.mock factories are hoisted — cannot reference top-level variables.
-// Use vi.hoisted() to define shared mocks.
-const { mockExecuteWorkflow, mockCreateClient } = vi.hoisted(() => {
-	const mockExecuteWorkflow = vi.fn().mockResolvedValue({ Message: "response", Encoding: "BASE64", Type: "JSON" });
-	const mockCreateClient = vi.fn().mockReturnValue({ executeWorkflow: mockExecuteWorkflow });
-	return { mockExecuteWorkflow, mockCreateClient };
-});
-
-vi.mock("@connectrpc/connect", () => ({
-	createClient: mockCreateClient,
-}));
-
-vi.mock("@connectrpc/connect-node", () => ({
-	createGrpcTransport: vi.fn().mockReturnValue({ type: "grpc" }),
-	createGrpcWebTransport: vi.fn().mockReturnValue({ type: "grpc-web" }),
-	createConnectTransport: vi.fn().mockReturnValue({ type: "connect" }),
-}));
-
-import { createConnectTransport, createGrpcTransport, createGrpcWebTransport } from "@connectrpc/connect-node";
-import GrpcClient, { TransportEnum, HttpVersionEnum, type RpcOptions } from "../../src/GrpcClient";
-
-describe("GrpcClient", () => {
-	const defaultOpts: RpcOptions = {
-		host: "localhost",
-		port: 8433,
-		protocol: "http",
-		httpVersion: HttpVersionEnum.HTTP2,
-		transport: TransportEnum.GRPC,
-	};
-
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	describe("constructor()", () => {
-		it("should store options", () => {
-			const client = new GrpcClient(defaultOpts);
-			expect(client).toBeDefined();
-		});
-	});
-
-	describe("transport()", () => {
-		it("should create gRPC transport for GRPC type", () => {
-			const client = new GrpcClient({ ...defaultOpts, transport: TransportEnum.GRPC });
-			const transport = client.transport();
-			expect(createGrpcTransport).toHaveBeenCalledWith({
-				baseUrl: "http://localhost:8433/",
-				interceptors: [],
-			});
-			expect(transport).toEqual({ type: "grpc" });
-		});
-
-		it("should create gRPC-Web transport for GRPC_WEB type", () => {
-			const client = new GrpcClient({ ...defaultOpts, transport: TransportEnum.GRPC_WEB });
-			const transport = client.transport();
-			expect(createGrpcWebTransport).toHaveBeenCalledWith({
-				baseUrl: "http://localhost:8433/",
-				httpVersion: HttpVersionEnum.HTTP2,
-				interceptors: [],
-			});
-			expect(transport).toEqual({ type: "grpc-web" });
-		});
-
-		it("should create Connect transport for CONNECT type", () => {
-			const client = new GrpcClient({ ...defaultOpts, transport: TransportEnum.CONNECT });
-			const transport = client.transport();
-			expect(createConnectTransport).toHaveBeenCalledWith({
-				baseUrl: "http://localhost:8433/",
-				httpVersion: HttpVersionEnum.HTTP2,
-				interceptors: [],
-			});
-			expect(transport).toEqual({ type: "connect" });
-		});
-
-		it("should throw for invalid transport type", () => {
-			const client = new GrpcClient({ ...defaultOpts, transport: "invalid" as TransportEnum });
-			expect(() => client.transport()).toThrow("Invalid transport type");
-		});
-
-		it("should use correct baseUrl with custom protocol and port", () => {
-			const client = new GrpcClient({
-				...defaultOpts,
-				protocol: "https",
-				host: "api.example.com",
-				port: 9090,
-				transport: TransportEnum.GRPC,
-			});
-			client.transport();
-			expect(createGrpcTransport).toHaveBeenCalledWith({
-				baseUrl: "https://api.example.com:9090/",
-				interceptors: [],
-			});
-		});
-	});
-
-	describe("call()", () => {
-		it("should create client and execute workflow", async () => {
-			const client = new GrpcClient(defaultOpts);
-			const message = {
-				Name: "test",
-				Message: "data",
-				Encoding: "BASE64",
-				Type: "JSON",
-			};
-
-			const result = await client.call(message as any);
-			expect(mockCreateClient).toHaveBeenCalled();
-			expect(mockExecuteWorkflow).toHaveBeenCalledWith(message, undefined);
-			expect(result).toEqual({ Message: "response", Encoding: "BASE64", Type: "JSON" });
-		});
-
-		it("should pass call options with headers", async () => {
-			const client = new GrpcClient(defaultOpts);
-			const message = { Name: "test", Message: "data", Encoding: "BASE64", Type: "JSON" };
-			const opts = { headers: { Authorization: "Bearer token123" } };
-
-			await client.call(message as any, opts);
-			expect(mockExecuteWorkflow).toHaveBeenCalledWith(message, opts);
-		});
-	});
-
-	describe("TransportEnum", () => {
-		it("should have correct values", () => {
-			expect(TransportEnum.GRPC).toBe("grpc");
-			expect(TransportEnum.GRPC_WEB).toBe("grpc-web");
-			expect(TransportEnum.CONNECT).toBe("connect");
-		});
-	});
-
-	describe("HttpVersionEnum", () => {
-		it("should have correct values", () => {
-			expect(HttpVersionEnum.HTTP1).toBe("1.1");
-			expect(HttpVersionEnum.HTTP2).toBe("2");
-		});
-	});
-});

package/__tests__/unit/GrpcServer.test.ts

@@ -1,127 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-// Use vi.hoisted for mocks referenced in vi.mock factories
-const { mockRegister, mockListen, mockAddresses } = vi.hoisted(() => {
-	const mockRegister = vi.fn().mockResolvedValue(undefined);
-	const mockListen = vi.fn().mockResolvedValue(undefined);
-	const mockAddresses = vi.fn().mockReturnValue([{ address: "0.0.0.0", port: 8443 }]);
-	return { mockRegister, mockListen, mockAddresses };
-});
-
-// Mock OpenTelemetry
-vi.mock("@opentelemetry/api", () => ({
-	trace: {
-		getTracer: () => ({
-			startActiveSpan: (_name: string, fn: (span: any) => any) =>
-				fn({
-					setAttribute: vi.fn(),
-					setStatus: vi.fn(),
-					end: vi.fn(),
-				}),
-		}),
-	},
-	metrics: {
-		getMeter: () => ({
-			createCounter: () => ({ add: vi.fn() }),
-			createGauge: () => ({ record: vi.fn() }),
-		}),
-	},
-	SpanStatusCode: { OK: 0, ERROR: 1 },
-}));
-
-// Mock fastify — must return a class-like constructor
-vi.mock("fastify", () => ({
-	default: () => ({
-		register: mockRegister,
-		listen: mockListen,
-		addresses: mockAddresses,
-	}),
-}));
-
-// Mock connect-fastify
-vi.mock("@connectrpc/connect-fastify", () => ({
-	fastifyConnectPlugin: "mocked-plugin",
-}));
-
-// Mock GRpcTrigger
-vi.mock("../../src/GRpcTrigger", () => {
-	return {
-		default: class MockGRpcTrigger {
-			getApp() {
-				return {
-					register: mockRegister,
-					listen: mockListen,
-					addresses: mockAddresses,
-				};
-			}
-			processRequest() {}
-		},
-	};
-});
-
-// Mock runner — DefaultLogger must be a class (used with new)
-vi.mock("@blokjs/runner", () => ({
-	DefaultLogger: class MockDefaultLogger {
-		log() {}
-		error() {}
-	},
-}));
-
-import GrpcServer from "../../src/GrpcServer";
-
-describe("GrpcServer", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	describe("constructor()", () => {
-		it("should create instance with provided options", () => {
-			const server = new GrpcServer({ host: "127.0.0.1", port: 9090 });
-			expect(server).toBeDefined();
-		});
-
-		it("should default host to 0.0.0.0 when undefined", () => {
-			const server = new GrpcServer({ host: undefined as any, port: 8443 });
-			expect(server).toBeDefined();
-		});
-
-		it("should default port to 8443 when undefined", () => {
-			const server = new GrpcServer({ host: "0.0.0.0", port: undefined as any });
-			expect(server).toBeDefined();
-		});
-
-		it("should default both host and port when undefined", () => {
-			const server = new GrpcServer({ host: undefined as any, port: undefined as any });
-			expect(server).toBeDefined();
-		});
-	});
-
-	describe("start()", () => {
-		it("should register connect plugin and listen", async () => {
-			const server = new GrpcServer({ host: "0.0.0.0", port: 8443 });
-			await server.start();
-			expect(mockRegister).toHaveBeenCalled();
-			expect(mockListen).toHaveBeenCalled();
-		});
-
-		it("should use GRPC_HOST env var when set", async () => {
-			const originalHost = process.env.GRPC_HOST;
-			process.env.GRPC_HOST = "10.0.0.1";
-			const server = new GrpcServer({ host: "0.0.0.0", port: 8443 });
-			await server.start();
-			const listenArgs = mockListen.mock.calls[0][0];
-			expect(listenArgs.host).toBe("10.0.0.1");
-			process.env.GRPC_HOST = originalHost;
-		});
-
-		it("should use GRPC_PORT env var when set", async () => {
-			const originalPort = process.env.GRPC_PORT;
-			process.env.GRPC_PORT = "9999";
-			const server = new GrpcServer({ host: "0.0.0.0", port: 8443 });
-			await server.start();
-			const listenArgs = mockListen.mock.calls[0][0];
-			expect(listenArgs.port).toBe(9999);
-			process.env.GRPC_PORT = originalPort;
-		});
-	});
-});

package/__tests__/unit/MessageDecode.test.ts

@@ -1,314 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import MessageDecode from "../../src/MessageDecode";
-import { MessageEncoding, MessageType } from "../../src/gen/workflow_pb";
-
-describe("MessageDecode", () => {
-	let decoder: MessageDecode;
-
-	beforeEach(() => {
-		decoder = new MessageDecode();
-	});
-
-	describe("requestDecode()", () => {
-		it("should decode BASE64 + JSON request", () => {
-			const payload = { request: { body: { key: "value" } } };
-			const base64 = Buffer.from(JSON.stringify(payload)).toString("base64");
-			const request = {
-				Name: "test",
-				Message: base64,
-				Encoding: MessageEncoding[MessageEncoding.BASE64],
-				Type: MessageType[MessageType.JSON],
-			};
-
-			const result = decoder.requestDecode(request as any);
-			expect(result).toEqual(payload);
-		});
-
-		it("should decode STRING + JSON request", () => {
-			const payload = { request: { body: { key: "value" } } };
-			const request = {
-				Name: "test",
-				Message: JSON.stringify(payload),
-				Encoding: MessageEncoding[MessageEncoding.STRING],
-				Type: MessageType[MessageType.JSON],
-			};
-
-			const result = decoder.requestDecode(request as any);
-			expect(result).toEqual(payload);
-		});
-
-		it("should decode BASE64 + XML request", () => {
-			const xml = "<root><key>value</key></root>";
-			const base64 = Buffer.from(xml).toString("base64");
-			const request = {
-				Name: "test",
-				Message: base64,
-				Encoding: MessageEncoding[MessageEncoding.BASE64],
-				Type: MessageType[MessageType.XML],
-			};
-
-			const result = decoder.requestDecode(request as any);
-			expect(result).toBeDefined();
-			expect((result as any).root).toBeDefined();
-		});
-
-		it("should decode STRING + XML request", () => {
-			const xml = "<root><key>value</key></root>";
-			const request = {
-				Name: "test",
-				Message: xml,
-				Encoding: MessageEncoding[MessageEncoding.STRING],
-				Type: MessageType[MessageType.XML],
-			};
-
-			const result = decoder.requestDecode(request as any);
-			expect(result).toBeDefined();
-			expect((result as any).root).toBeDefined();
-		});
-
-		it("should throw for unsupported encoding", () => {
-			const request = {
-				Name: "test",
-				Message: "data",
-				Encoding: "UNKNOWN",
-				Type: MessageType[MessageType.JSON],
-			};
-
-			expect(() => decoder.requestDecode(request as any)).toThrow("Unsupported encoding: UNKNOWN");
-		});
-	});
-
-	describe("decodeType()", () => {
-		it("should decode JSON string to object", () => {
-			const json = '{"key":"value"}';
-			const result = decoder.decodeType(json, MessageType[MessageType.JSON]);
-			expect(result).toEqual({ key: "value" });
-		});
-
-		it("should decode XML string to object", () => {
-			const xml = "<root><item>test</item></root>";
-			const result = decoder.decodeType(xml, MessageType[MessageType.XML]);
-			expect(result).toBeDefined();
-			expect((result as any).root).toBeDefined();
-		});
-
-		it("should throw for unsupported type", () => {
-			expect(() => decoder.decodeType("data", "BINARY")).toThrow("Unsupported type: BINARY");
-		});
-
-		it("should throw for TEXT type (not supported in decode)", () => {
-			expect(() => decoder.decodeType("data", MessageType[MessageType.TEXT])).toThrow("Unsupported type: TEXT");
-		});
-	});
-
-	describe("responseEncode()", () => {
-		it("should encode response with BASE64 + JSON", () => {
-			const ctx = {
-				response: {
-					data: { result: "ok" },
-					contentType: "application/json",
-				},
-			};
-
-			const result = decoder.responseEncode(
-				ctx as any,
-				MessageEncoding[MessageEncoding.BASE64],
-				MessageType[MessageType.JSON],
-			);
-
-			expect(result.Encoding).toBe(MessageEncoding[MessageEncoding.BASE64]);
-			expect(result.Type).toBe(MessageType[MessageType.JSON]);
-			// The message should be base64 encoded
-			const decoded = Buffer.from(result.Message, "base64").toString("utf-8");
-			expect(JSON.parse(decoded)).toEqual({ result: "ok" });
-		});
-
-		it("should encode response with STRING + JSON", () => {
-			const ctx = {
-				response: {
-					data: { result: "ok" },
-					contentType: "application/json",
-				},
-			};
-
-			const result = decoder.responseEncode(
-				ctx as any,
-				MessageEncoding[MessageEncoding.STRING],
-				MessageType[MessageType.JSON],
-			);
-
-			expect(result.Encoding).toBe(MessageEncoding[MessageEncoding.STRING]);
-		});
-
-		it("should encode response with TEXT content type", () => {
-			const ctx = {
-				response: {
-					data: "hello world",
-					contentType: "text/plain",
-				},
-			};
-
-			const result = decoder.responseEncode(
-				ctx as any,
-				MessageEncoding[MessageEncoding.STRING],
-				MessageType[MessageType.TEXT],
-			);
-
-			expect(result.Encoding).toBe(MessageEncoding[MessageEncoding.STRING]);
-			expect(result.Type).toBe(MessageType[MessageType.TEXT]);
-		});
-
-		it("should throw for unsupported encoding", () => {
-			const ctx = {
-				response: {
-					data: "test",
-					contentType: "text/plain",
-				},
-			};
-
-			expect(() => decoder.responseEncode(ctx as any, "UNKNOWN", MessageType[MessageType.JSON])).toThrow(
-				"Unsupported encoding: UNKNOWN",
-			);
-		});
-	});
-
-	describe("responseErrorEncode()", () => {
-		it("should encode error with BASE64", () => {
-			const result = decoder.responseErrorEncode(
-				"Error occurred",
-				MessageEncoding[MessageEncoding.BASE64],
-				MessageType[MessageType.TEXT],
-			);
-
-			const decoded = Buffer.from(result, "base64").toString("utf-8");
-			expect(decoded).toBe("Error occurred");
-		});
-
-		it("should encode error with STRING", () => {
-			const result = decoder.responseErrorEncode(
-				"Error occurred",
-				MessageEncoding[MessageEncoding.STRING],
-				MessageType[MessageType.TEXT],
-			);
-
-			expect(result).toBe("Error occurred");
-		});
-
-		it("should encode JSON error with BASE64", () => {
-			const error = JSON.stringify({ code: 500, message: "Server error" });
-			const result = decoder.responseErrorEncode(
-				error,
-				MessageEncoding[MessageEncoding.BASE64],
-				MessageType[MessageType.JSON],
-			);
-
-			const decoded = Buffer.from(result, "base64").toString("utf-8");
-			expect(JSON.parse(decoded)).toBe(error);
-		});
-
-		it("should throw for unsupported encoding", () => {
-			expect(() => decoder.responseErrorEncode("Error", "UNKNOWN", MessageType[MessageType.TEXT])).toThrow(
-				"Unsupported encoding: UNKNOWN",
-			);
-		});
-	});
-
-	describe("responseDecode()", () => {
-		it("should decode BASE64 + JSON response", () => {
-			const data = { result: "ok" };
-			const base64 = Buffer.from(JSON.stringify(data)).toString("base64");
-			const response = {
-				Message: base64,
-				Encoding: MessageEncoding[MessageEncoding.BASE64],
-				Type: MessageType[MessageType.JSON],
-			};
-
-			const result = decoder.responseDecode(response as any);
-			expect(result).toEqual(data);
-		});
-
-		it("should decode STRING + JSON response", () => {
-			const data = { result: "ok" };
-			const response = {
-				Message: JSON.stringify(data),
-				Encoding: MessageEncoding[MessageEncoding.STRING],
-				Type: MessageType[MessageType.JSON],
-			};
-
-			const result = decoder.responseDecode(response as any);
-			expect(result).toEqual(data);
-		});
-
-		it("should decode BASE64 + XML response", () => {
-			const xml = "<root><key>value</key></root>";
-			const base64 = Buffer.from(xml).toString("base64");
-			const response = {
-				Message: base64,
-				Encoding: MessageEncoding[MessageEncoding.BASE64],
-				Type: MessageType[MessageType.XML],
-			};
-
-			const result = decoder.responseDecode(response as any);
-			expect(result).toBeDefined();
-		});
-
-		it("should throw for unsupported encoding in response", () => {
-			const response = {
-				Message: "data",
-				Encoding: "UNKNOWN",
-				Type: MessageType[MessageType.JSON],
-			};
-
-			expect(() => decoder.responseDecode(response as any)).toThrow("Unsupported encoding: UNKNOWN");
-		});
-	});
-
-	describe("encodeType()", () => {
-		it("should encode object to JSON string", () => {
-			const result = decoder.encodeType({ key: "value" }, MessageType[MessageType.JSON]);
-			expect(result).toBe('{"key":"value"}');
-		});
-
-		it("should encode TEXT to string", () => {
-			const result = decoder.encodeType("hello", MessageType[MessageType.TEXT]);
-			expect(result).toBe("hello");
-		});
-
-		it("should encode HTML to string", () => {
-			const result = decoder.encodeType("<h1>Hello</h1>", MessageType[MessageType.HTML]);
-			expect(result).toBe("<h1>Hello</h1>");
-		});
-
-		it("should encode object to XML string", () => {
-			const result = decoder.encodeType({ root: { key: "value" } }, MessageType[MessageType.XML]);
-			expect(typeof result).toBe("string");
-			expect(result).toContain("key");
-		});
-
-		it("should throw for unsupported type", () => {
-			expect(() => decoder.encodeType("data", "BINARY")).toThrow("Unsupported type: BINARY");
-		});
-	});
-
-	describe("mapContentType()", () => {
-		it("should map application/json to JSON", () => {
-			expect(decoder.mapContentType("application/json")).toBe(MessageType.JSON);
-		});
-
-		it("should map text/html to HTML", () => {
-			expect(decoder.mapContentType("text/html")).toBe(MessageType.HTML);
-		});
-
-		it("should map text/xml to XML", () => {
-			expect(decoder.mapContentType("text/xml")).toBe(MessageType.XML);
-		});
-
-		it("should default to TEXT for unknown content type", () => {
-			expect(decoder.mapContentType("text/plain")).toBe(MessageType.TEXT);
-		});
-
-		it("should default to TEXT for empty string", () => {
-			expect(decoder.mapContentType("")).toBe(MessageType.TEXT);
-		});
-	});
-});