@blokjs/trigger-grpc 0.2.0

package/.env.example

@@ -0,0 +1,8 @@
+PROJECT_NAME=trigger-grpc-server
+PROJECT_VERSION=0.0.1
+GRPC_PORT=8433
+GRPC_HOST=0.0.0.0
+WORKFLOWS_PATH=PROJECT_PATH/workflows
+NODES_PATH=PROJECT_PATH/src/nodes
+CONSOLE_LOG_ACTIVE=true
+APP_NAME=blok-grpc

package/CHANGELOG.md

@@ -0,0 +1,143 @@
+# @blokjs/trigger-grpc
+
+## 0.2.0
+
+### Minor Changes
+
+- Initial public release of Blok packages.
+
+  This release includes:
+
+  - Core packages: @blokjs/shared, @blokjs/helper, @blokjs/runner
+  - Node packages: @blokjs/api-call, @blokjs/if-else, @blokjs/react
+  - Trigger packages: pubsub, queue, webhook, websocket, worker, cron, grpc
+  - CLI tool: blokctl
+  - Editor support: @blokjs/lsp-server, @blokjs/syntax
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/shared@0.2.0
+  - @blokjs/helper@0.2.0
+  - @blokjs/runner@0.2.0
+  - @blokjs/api-call@0.2.0
+  - @blokjs/if-else@0.2.0
+
+## 0.0.14
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.26
+  - @blokjs/if-else@0.0.30
+  - @blokjs/api-call@0.1.29
+
+## 0.0.13
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.25
+  - @blokjs/if-else@0.0.29
+  - @blokjs/api-call@0.1.28
+
+## 0.0.12
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.24
+  - @blokjs/if-else@0.0.28
+  - @blokjs/api-call@0.1.27
+
+## 0.0.11
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.23
+  - @blokjs/if-else@0.0.27
+  - @blokjs/api-call@0.1.26
+
+## 0.0.10
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.22
+  - @blokjs/if-else@0.0.26
+  - @blokjs/api-call@0.1.25
+
+## 0.0.9
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.21
+  - @blokjs/if-else@0.0.25
+  - @blokjs/api-call@0.1.24
+
+## 0.0.8
+
+### Patch Changes
+
+- added GRPC remote node execution server and client (NodeJS)
+- Updated dependencies
+  - @blokjs/helper@0.1.5
+  - @blokjs/runner@0.1.20
+  - @blokjs/if-else@0.0.24
+  - @blokjs/api-call@0.1.23
+
+## 0.0.7
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.19
+  - @blokjs/shared@0.0.9
+  - @blokjs/if-else@0.0.23
+  - @blokjs/api-call@0.1.22
+
+## 0.0.6
+
+### Patch Changes
+
+- Added examples and create project' command to include examples and 'create node' command with options for type ('module' or 'class') and template ('class' or 'ui')
+- Updated dependencies
+  - @blokjs/if-else@0.0.22
+  - @blokjs/api-call@0.1.21
+  - @blokjs/runner@0.1.18
+  - @blokjs/shared@0.0.8
+
+## 0.0.5
+
+### Patch Changes
+
+- Successfully implemented all the enhancements and improvements identified during our internal hackathon.
+
+## 0.0.4
+
+### Patch Changes
+
+- Updated dependencies
+  - @blokjs/runner@0.1.17
+  - @blokjs/if-else@0.0.21
+  - @blokjs/api-call@0.1.20
+
+## 0.0.3
+
+### Patch Changes
+
+- Added support for YAML, XML and TOML in the workflow file. Upgraded package version recommended by Dependabot.
+- Updated dependencies
+  - @blokjs/if-else@0.0.20
+  - @blokjs/api-call@0.1.19
+  - @blokjs/helper@0.1.4
+  - @blokjs/runner@0.1.16
+  - @blokjs/shared@0.0.7
+
+## 0.0.2
+
+### Patch Changes
+
+- Implemented grpc client library

package/README.md

@@ -0,0 +1,25 @@
+# Use the gRPC protocol instead of the Connect protocol
+
+On Node.js, we support three protocols:
+
+1. The gRPC protocol that is used throughout the gRPC ecosystem.
+2. The gRPC-Web protocol used by grpc/grpc-web, allowing servers to interop with grpc-web front-ends without the need for an intermediary proxy (such as Envoy).
+3. The new Connect protocol, a simple, HTTP-based protocol that works over HTTP/1.1 or HTTP/2. It takes the best portions of gRPC and gRPC-Web, including streaming, and packages them into a protocol that works equally well in browsers, monoliths, and microservices. The Connect protocol is what we think the gRPC protocol should be. By default, JSON- and binary-encoded Protobuf is supported.
+
+So far, we have been using the ```http://``` scheme in our examples. We were not using TLS (Transport Layer Security). If you want to use gRPC and browser clients during local development, you need TLS.
+
+Actually, that only takes a minute to set up! We will use ```mkcert``` to make a certificate. If you don't have it installed yet, please run the following commands:
+
+```bash
+brew install mkcert
+mkcert -install
+mkcert localhost 127.0.0.1 ::1
+export NODE_EXTRA_CA_CERTS="$(mkcert -CAROOT)/rootCA.pem"
+```
+
+If you don't use macOS or ```brew```, see the mkcert docs for instructions. You can copy the last line to your ```~/.zprofile``` or ```~/.profile```, so that the environment variable for Node.js is set every time you open a terminal.
+
+If you already use ```mkcert```, just run ```mkcert localhost 127.0.0.1 ::1``` to issue a certificate for our example server.
+
+Reference:
+https://connectrpc.com/docs/node/getting-started/

package/__tests__/unit/GRpcTrigger.test.ts

@@ -0,0 +1,313 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock OpenTelemetry
+vi.mock("@opentelemetry/api", () => ({
+	trace: {
+		getTracer: () => ({
+			startActiveSpan: (_name: string, fn: (span: any) => any) =>
+				fn({
+					setAttribute: vi.fn(),
+					setStatus: vi.fn(),
+					recordException: vi.fn(),
+					end: vi.fn(),
+				}),
+		}),
+	},
+	metrics: {
+		getMeter: () => ({
+			createCounter: () => ({ add: vi.fn() }),
+			createGauge: () => ({ record: vi.fn() }),
+		}),
+	},
+	SpanStatusCode: { OK: 0, ERROR: 1 },
+}));
+
+// Mock fastify — must be a callable function (not arrow, since source may use `new`)
+vi.mock("fastify", () => ({
+	default: () => ({
+		register: vi.fn(),
+		listen: vi.fn(),
+		use: vi.fn(),
+	}),
+}));
+
+// Mock uuid
+vi.mock("uuid", () => ({ v4: () => "test-uuid-1234" }));
+
+// Mock Nodes and Workflows
+vi.mock("../../src/Nodes", () => ({ default: {} }));
+vi.mock("../../src/Workflows", () => ({ default: {} }));
+
+// Mock runner — TriggerBase and other classes must be constructable
+vi.mock("@blokjs/runner", () => {
+	class MockNodeMap {
+		nodes: Record<string, any> = {};
+		addNode(key: string, val: any) {
+			this.nodes[key] = val;
+		}
+	}
+
+	class MockTriggerBase {
+		configuration: any;
+		nodeMap: any;
+		constructor() {
+			this.configuration = {
+				name: "test-workflow",
+				version: "1.0.0",
+				init: vi.fn().mockResolvedValue(undefined),
+			};
+		}
+		createContext(_: any, name: string, id: string) {
+			return {
+				id,
+				request: { body: {}, headers: {}, query: {}, params: {} },
+				response: { data: { ok: true }, error: null, success: true, contentType: "application/json" },
+				error: { message: "" },
+				logger: { log: vi.fn(), error: vi.fn() },
+			};
+		}
+		async run(ctx: any) {
+			return {
+				ctx,
+				metrics: {
+					memory: { total: 10, min: 5, max: 15 },
+					cpu: { average: 50, total: 100, usage: 75, model: "test-cpu" },
+				},
+			};
+		}
+	}
+
+	return {
+		DefaultLogger: class {
+			log() {}
+			error() {}
+		},
+		NodeMap: MockNodeMap,
+		TriggerBase: MockTriggerBase,
+	};
+});
+
+// Mock helper
+vi.mock("@blokjs/helper", () => ({
+	Workflow: vi.fn().mockReturnValue({
+		addTrigger: vi.fn().mockReturnValue({
+			addStep: vi.fn().mockReturnValue({ name: "Remote Node", steps: [] }),
+		}),
+	}),
+}));
+
+// Mock shared — GlobalError must be a class
+vi.mock("@blokjs/shared", () => ({
+	GlobalError: class GlobalError extends Error {
+		context: any;
+		constructor(message: string) {
+			super(message);
+			this.context = { message, code: undefined, json: null };
+		}
+		setCode(code: number) {
+			this.context.code = code;
+		}
+		hasJson() {
+			return this.context.json !== null && this.context.json !== undefined;
+		}
+	},
+}));
+
+import GRpcTrigger from "../../src/GRpcTrigger";
+import { MessageEncoding, MessageType } from "../../src/gen/workflow_pb";
+
+describe("GRpcTrigger", () => {
+	let trigger: GRpcTrigger;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		trigger = new GRpcTrigger();
+	});
+
+	describe("constructor()", () => {
+		it("should create instance without errors", () => {
+			expect(trigger).toBeDefined();
+		});
+
+		it("should call loadNodes and loadWorkflows", () => {
+			expect(trigger.getApp()).toBeDefined();
+		});
+	});
+
+	describe("getApp()", () => {
+		it("should return fastify instance", () => {
+			const app = trigger.getApp();
+			expect(app).toBeDefined();
+			expect(typeof app.register).toBe("function");
+		});
+	});
+
+	describe("listen()", () => {
+		it("should return 0", async () => {
+			const result = await trigger.listen();
+			expect(result).toBe(0);
+		});
+	});
+
+	describe("processRequest()", () => {
+		it("should register WorkflowService on the router", () => {
+			const mockService = vi.fn();
+			const mockRouter = { service: mockService };
+			trigger.processRequest(mockRouter as any, trigger);
+			expect(mockService).toHaveBeenCalled();
+		});
+	});
+
+	describe("executeWorkflow()", () => {
+		it("should execute workflow and return encoded response", async () => {
+			const payload = {
+				request: { body: {}, headers: {}, query: {}, params: {} },
+				response: { data: null, error: null, success: true },
+			};
+			const base64 = Buffer.from(JSON.stringify(payload)).toString("base64");
+			const request = {
+				Name: "test-workflow",
+				Message: base64,
+				Encoding: MessageEncoding[MessageEncoding.BASE64],
+				Type: MessageType[MessageType.JSON],
+			};
+
+			const result = await trigger.executeWorkflow(request as any);
+			expect(result).toBeDefined();
+			expect(result.Encoding).toBeDefined();
+		});
+
+		it("should use requestId from query when available", async () => {
+			const payload = {
+				request: { body: {}, headers: {}, query: { requestId: "custom-req-id" }, params: {} },
+				response: { data: null, error: null, success: true },
+			};
+			const base64 = Buffer.from(JSON.stringify(payload)).toString("base64");
+			const request = {
+				Name: "test-workflow",
+				Message: base64,
+				Encoding: MessageEncoding[MessageEncoding.BASE64],
+				Type: MessageType[MessageType.JSON],
+			};
+
+			const result = await trigger.executeWorkflow(request as any);
+			expect(result).toBeDefined();
+		});
+
+		it("should handle remote node execution with workflow model", async () => {
+			const payload = {
+				request: { body: {}, headers: {}, query: {}, params: {} },
+				workflow: {
+					name: "Remote Node",
+					version: "1.0.0",
+					description: "Test",
+					trigger: { grpc: {} },
+					steps: [{ name: "node", node: "test-node", type: "module" }],
+					nodes: { node: { inputs: {} } },
+				},
+			};
+			const base64 = Buffer.from(JSON.stringify(payload)).toString("base64");
+			const request = {
+				Name: "test-node",
+				Message: base64,
+				Encoding: MessageEncoding[MessageEncoding.BASE64],
+				Type: MessageType[MessageType.JSON],
+			};
+
+			const result = await trigger.executeWorkflow(request as any);
+			expect(result).toBeDefined();
+		});
+
+		it("should handle runtime.python3 node type", async () => {
+			const payload = {
+				request: { body: {}, headers: {}, query: {}, params: {} },
+				workflow: {
+					name: "Remote Node",
+					version: "1.0.0",
+					description: "Test",
+					trigger: { grpc: {} },
+					steps: [{ name: "node", node: "py-node", type: "runtime.python3" }],
+					nodes: { node: { inputs: {} } },
+				},
+			};
+			const base64 = Buffer.from(JSON.stringify(payload)).toString("base64");
+			const request = {
+				Name: "py-node",
+				Message: base64,
+				Encoding: MessageEncoding[MessageEncoding.BASE64],
+				Type: MessageType[MessageType.JSON],
+			};
+
+			const result = await trigger.executeWorkflow(request as any);
+			expect(result).toBeDefined();
+		});
+
+		it("should handle local node type", async () => {
+			const payload = {
+				request: { body: {}, headers: {}, query: {}, params: {} },
+				workflow: {
+					name: "Remote Node",
+					version: "1.0.0",
+					description: "Test",
+					trigger: { grpc: {} },
+					steps: [{ name: "node", node: "local-node", type: "local" }],
+					nodes: { node: { inputs: {} } },
+				},
+			};
+			const base64 = Buffer.from(JSON.stringify(payload)).toString("base64");
+			const request = {
+				Name: "local-node",
+				Message: base64,
+				Encoding: MessageEncoding[MessageEncoding.BASE64],
+				Type: MessageType[MessageType.JSON],
+			};
+
+			const result = await trigger.executeWorkflow(request as any);
+			expect(result).toBeDefined();
+		});
+
+		it("should handle generic Error during execution", async () => {
+			const failTrigger = new GRpcTrigger();
+			(failTrigger as any).configuration.init = vi.fn().mockRejectedValue(new Error("Init failed"));
+
+			const payload = {
+				request: { body: {}, headers: {}, query: {}, params: {} },
+			};
+			const base64 = Buffer.from(JSON.stringify(payload)).toString("base64");
+			const request = {
+				Name: "fail-workflow",
+				Message: base64,
+				Encoding: MessageEncoding[MessageEncoding.BASE64],
+				Type: MessageType[MessageType.JSON],
+			};
+
+			const result = await failTrigger.executeWorkflow(request as any);
+			expect(result).toBeDefined();
+			expect(result.Encoding).toBe(MessageEncoding[MessageEncoding.BASE64]);
+		});
+
+		it("should set default contentType when empty", async () => {
+			const payload = {
+				request: { body: {}, headers: {}, query: {}, params: {} },
+			};
+			const base64 = Buffer.from(JSON.stringify(payload)).toString("base64");
+			const request = {
+				Name: "test-workflow",
+				Message: base64,
+				Encoding: MessageEncoding[MessageEncoding.BASE64],
+				Type: MessageType[MessageType.JSON],
+			};
+
+			// Override createContext to return empty contentType
+			const origCreateContext = (trigger as any).createContext.bind(trigger);
+			(trigger as any).createContext = (_: any, name: string, id: string) => {
+				const ctx = origCreateContext(_, name, id);
+				ctx.response.contentType = "";
+				return ctx;
+			};
+
+			const result = await trigger.executeWorkflow(request as any);
+			expect(result).toBeDefined();
+		});
+	});
+});

package/__tests__/unit/GrpcClient.test.ts

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