@blokjs/trigger-grpc 0.2.0

package/__tests__/unit/GrpcServer.test.ts

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,314 @@
+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);
+		});
+	});
+});

package/__tests__/unit/NanoSDK.test.ts

@@ -0,0 +1,162 @@
+import fs from "node:fs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// Use vi.hoisted for mocks referenced inside vi.mock factories
+const { mockCall } = vi.hoisted(() => {
+	const mockCall = vi.fn().mockResolvedValue({
+		Message: Buffer.from(JSON.stringify({ result: "ok" })).toString("base64"),
+		Encoding: "BASE64",
+		Type: "JSON",
+	});
+	return { mockCall };
+});
+
+vi.mock("../../src/GrpcClient", () => {
+	class MockGrpcClient {
+		call = mockCall;
+	}
+	return {
+		default: MockGrpcClient,
+		HttpVersionEnum: { HTTP1: "1.1", HTTP2: "2" },
+		TransportEnum: { GRPC: "grpc", GRPC_WEB: "grpc-web", CONNECT: "connect" },
+	};
+});
+
+vi.mock("../../src/MessageDecode", () => {
+	class MockMessageDecode {
+		responseDecode() {
+			return { result: "ok" };
+		}
+	}
+	return { default: MockMessageDecode };
+});
+
+import NanoSDK, { NanoSDKClient } from "../../src/NanoSDK";
+
+describe("NanoSDK", () => {
+	let sdk: NanoSDK;
+
+	beforeEach(() => {
+		sdk = new NanoSDK();
+		vi.clearAllMocks();
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	describe("createClient()", () => {
+		it("should create client with explicit host and token", () => {
+			const client = sdk.createClient("localhost:8433", "my-token");
+			expect(client).toBeDefined();
+			expect(client).toBeInstanceOf(NanoSDKClient);
+		});
+
+		it("should create client with host only (empty token)", () => {
+			const client = sdk.createClient("myhost:9090");
+			expect(client).toBeDefined();
+		});
+
+		it("should read nanosdk.json when no host provided", () => {
+			vi.spyOn(fs, "existsSync").mockReturnValue(true);
+			vi.spyOn(fs, "readFileSync").mockReturnValue(JSON.stringify({ host: "127.0.0.1:5000", token: "file-token" }));
+
+			const client = sdk.createClient();
+			expect(fs.existsSync).toHaveBeenCalled();
+			expect(fs.readFileSync).toHaveBeenCalled();
+			expect(client).toBeDefined();
+		});
+
+		it("should use default host when no host and no nanosdk.json", () => {
+			vi.spyOn(fs, "existsSync").mockReturnValue(false);
+
+			const client = sdk.createClient();
+			expect(client).toBeDefined();
+		});
+
+		it("should throw for host without port and without protocol", () => {
+			expect(() => sdk.createClient("invalidhost")).toThrow(
+				"Invalid host format. The host must have the format domain:port",
+			);
+		});
+
+		it("should accept host with http:// prefix", () => {
+			const client = sdk.createClient("http://localhost");
+			expect(client).toBeDefined();
+		});
+
+		it("should accept host with https:// prefix", () => {
+			const client = sdk.createClient("https://myserver");
+			expect(client).toBeDefined();
+		});
+	});
+});
+
+describe("NanoSDKClient", () => {
+	let client: NanoSDKClient;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		const sdk = new NanoSDK();
+		client = sdk.createClient("localhost:8433", "test-token");
+	});
+
+	describe("python3()", () => {
+		it("should build correct request for Python3 node", async () => {
+			const result = await client.python3("my-node", { url: "http://example.com" });
+			expect(mockCall).toHaveBeenCalled();
+			const callArgs = mockCall.mock.calls[0];
+			const request = callArgs[0];
+			expect(request.Name).toBe("my-node");
+			expect(request.Encoding).toBe("BASE64");
+			expect(request.Type).toBe("JSON");
+			const decoded = JSON.parse(Buffer.from(request.Message, "base64").toString("utf-8"));
+			expect(decoded.workflow.steps[0].type).toBe("runtime.python3");
+			expect(decoded.workflow.steps[0].node).toBe("my-node");
+		});
+
+		it("should pass inputs to the workflow node config", async () => {
+			const inputs = { url: "http://api.com", method: "POST" };
+			await client.python3("api-call", inputs);
+			const request = mockCall.mock.calls[0][0];
+			const decoded = JSON.parse(Buffer.from(request.Message, "base64").toString("utf-8"));
+			expect(decoded.workflow.nodes.node.inputs).toEqual(inputs);
+		});
+
+		it("should return decoded response", async () => {
+			const result = await client.python3("my-node", {});
+			expect(result).toEqual({ result: "ok" });
+		});
+	});
+
+	describe("nodejs()", () => {
+		it("should build correct request for Node.js node", async () => {
+			await client.nodejs("my-node", { data: "test" });
+			const request = mockCall.mock.calls[0][0];
+			const decoded = JSON.parse(Buffer.from(request.Message, "base64").toString("utf-8"));
+			expect(decoded.workflow.steps[0].type).toBe("module");
+			expect(decoded.workflow.steps[0].node).toBe("my-node");
+		});
+
+		it("should use custom type parameter", async () => {
+			await client.nodejs("my-node", {}, "local");
+			const request = mockCall.mock.calls[0][0];
+			const decoded = JSON.parse(Buffer.from(request.Message, "base64").toString("utf-8"));
+			expect(decoded.workflow.steps[0].type).toBe("local");
+		});
+
+		it("should include http trigger in workflow", async () => {
+			await client.nodejs("my-node", {});
+			const request = mockCall.mock.calls[0][0];
+			const decoded = JSON.parse(Buffer.from(request.Message, "base64").toString("utf-8"));
+			expect(decoded.workflow.trigger.http).toBeDefined();
+			expect(decoded.workflow.trigger.http.method).toBe("GET");
+		});
+
+		it("should pass authorization header", async () => {
+			await client.nodejs("my-node", {});
+			const callOpts = mockCall.mock.calls[0][1];
+			expect(callOpts.headers.Authorization).toBe("Bearer test-token");
+		});
+	});
+});

package/__tests__/unit/Nodes.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import nodes from "../../src/Nodes";
+
+describe("Nodes", () => {
+	it("should export an object with node keys", () => {
+		expect(typeof nodes).toBe("object");
+	});
+
+	it("should have @blokjs/api-call key", () => {
+		expect(nodes["@blokjs/api-call"]).toBeDefined();
+	});
+
+	it("should have @blokjs/if-else key", () => {
+		expect(nodes["@blokjs/if-else"]).toBeDefined();
+	});
+});

package/buf.gen.yaml

@@ -0,0 +1,11 @@
+version: v2
+clean: true
+plugins:
+  - local: protoc-gen-es
+    opt: target=ts
+    out: src/gen
+    include_imports: true
+  # - local: protoc-gen-connect-es 
+  #   opt: target=ts
+  #   out: src
+  #   include_imports: true

package/buf.yaml

@@ -0,0 +1,9 @@
+version: v2
+breaking:
+  use:
+    - FILE
+lint:
+  use:
+    - STANDARD
+modules:
+  - path: proto

package/dist/GRpcTrigger.d.ts

@@ -0,0 +1,18 @@
+import type { ConnectRouter } from "@connectrpc/connect";
+import { TriggerBase } from "@blok/runner";
+import { type WorkflowRequest, type WorkflowResponse } from "./gen/workflow_pb";
+export default class GRpcTrigger extends TriggerBase {
+    private server;
+    private nodeMap;
+    protected tracer: import("@opentelemetry/api").Tracer;
+    private logger;
+    constructor();
+    getApp(): import("fastify").FastifyInstance<import("http2").Http2Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse, typeof import("http2").Http2ServerRequest, typeof import("http2").Http2ServerResponse>, import("http2").Http2ServerRequest, import("http2").Http2ServerResponse<import("http2").Http2ServerRequest>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault> & PromiseLike<import("fastify").FastifyInstance<import("http2").Http2Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse, typeof import("http2").Http2ServerRequest, typeof import("http2").Http2ServerResponse>, import("http2").Http2ServerRequest, import("http2").Http2ServerResponse<import("http2").Http2ServerRequest>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>> & {
+        __linterBrands: "SafePromiseLike";
+    };
+    listen(): Promise<number>;
+    loadNodes(): void;
+    loadWorkflows(): void;
+    processRequest(router: ConnectRouter, trigger: GRpcTrigger): void;
+    executeWorkflow(request: WorkflowRequest): Promise<WorkflowResponse>;
+}