@blokjs/trigger-grpc 0.6.18 → 0.6.19

package/__tests__/unit/NanoSDK.test.ts

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

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

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

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

package/localhost+2-key.pem

@@ -1,28 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDNjfXRKBwXU0IH
-ftJJGiR5w6Ccf2JfPZJgDdarhVgJjL2cy9d4AwIq4ydiuU+H8MnguzdGrFaCgYOB
-GfgEI4dOAGr1AInRVVHRWKvwGdLYm59dBRi5PQuU2EKVonQNsZy/qcOJSBzBSSAx
-PFCpTwrxj0j/Dug6LxIa1wB7UenYn5NjkFSF8F5HufE7l4goIVh0/fVgRripCsnk
-iMQFVhMr+2glX+19zTVkBl9EtAPbkXsegUUdnkOH2sd1TBN4HUibnktX+P1aIlhd
-p741Eni42jU92u33iZasvvnkA94Q2MhBhzx3lgqAAcHcePzBI9yOEQbTqik4Nkpv
-moqqDFBbAgMBAAECggEACDu0aeFCZsjF70jsIVNzvJDSYRJVHV14/HHxdENOCGvj
-uGENy1fLgW5ByJmFjvtdCqxVBXanrGiFnOkuXvQRWlV380JHQuQ497qmgGJ4aIar
-Nm2a1OiWCysyV43/OgEwNxkUpO4HgNJuAKrazD1HQe+sS9MMCDCUeBC+izH3vN5s
-9LWOrhde+ZwCkHJgRxp6V5HBJXU/27T02ZjgvPXupzXQ2ozRgx2gn5lLvJJfqG/h
-jEMi9qyuwoRUL4QXDg3TNHHSllnENdRrVJr7VsvYpRpQogVsr4V7zIZiFkAcbuC4
-kMuHeahkjqmlSYVuz9DxPHcmFRW/B5MI5MLQwCvI6QKBgQD61emfMrA323QIWF5l
-hbNQBS3hje9pwN27EU3QmCq0z/2Ja0TTaSeNSdlQAfMEGHsO5tL0ldqS267uqs5r
-clrukrOFmcARZiHne5U1uMcWgYvRmPTTdwng1lQSBuLo7XR9f6sW3u1csOJ8PY4w
-oKtsAIKm0r53iVRCPpd7D9Lr3QKBgQDRyWIccS93kI2rmRxkg4nhniCP8uAacYHy
-ZEZUFpm0p23rLKF7zlGd1xZmwKV5lnd1278qBt9YMvDGw6Mlt3WTQUh9XQ3b5q1V
-xOHfyn2QvWfFbX/tWousq2RP3CJakGiKMefSx8aZB/Vwat3kSdgz825Vcr9oN2j1
-lZZemRlllwKBgD+K1QXpN07PHxPGHxOkzQnmZfsPk6i8nO74sTe4dIkdb2LSc7sC
-lmxqWsyz0bYl5Xae7q3bEGXHlQcM6gG6FGL/cs7TZh6COvCDFAdp6bU/2AWes9al
-/zCf2ug+KllLXgk0wEio7IRgot9KUKzs5sATWQWduXZaqaemZ4VbOtlZAoGAK457
-b1pUt6dssq8khP4Gl7CEJD8SJotgppoJPBZBLZABs21dzd3FdlcdEJJ5COijvvW0
-GB67Ko3RDgO6kO8pWzyXt2elo/2eCYvKNfPN5EpfDE+y2u4Mx/oB5s7W1yTaf67i
-6hGOe2F6pS+bCHYIjKjDRLyBXzr58NtxEA0Lh9sCgYEA6dI03OhJpruHxyOE3HYE
-oSDah3wr8WUw5BsGDsrW2tMVV7Y3YRO02mL/DB17bmM1FzS5s0n8DKU0c2wViFm4
-ZI4wZdm1hA1MBQBEFVQlVkmwtfyhmsnr98Huckd58PfMUZf6KJE9L4h7SXtPa/VL
-492ASgwAEWWqFlfK6wSrHiM=
------END PRIVATE KEY-----

package/localhost+2.pem

@@ -1,27 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIEoTCCAwmgAwIBAgIRAKSu5ey0gTHNC82jEhdfdpYwDQYJKoZIhvcNAQELBQAw
-gbExHjAcBgNVBAoTFW1rY2VydCBkZXZlbG9wbWVudCBDQTFDMEEGA1UECww6bWFy
-Y29ATWFyY29zLU1hY0Jvb2stUHJvLmxvY2FsIChNYXJjbyBDYXN0aWxsbyBEZWxs
-YSBTZXJhKTFKMEgGA1UEAwxBbWtjZXJ0IG1hcmNvQE1hcmNvcy1NYWNCb29rLVBy
-by5sb2NhbCAoTWFyY28gQ2FzdGlsbG8gRGVsbGEgU2VyYSkwHhcNMjUwMjAzMDE1
-MjM5WhcNMjcwNTAzMDE1MjM5WjBuMScwJQYDVQQKEx5ta2NlcnQgZGV2ZWxvcG1l
-bnQgY2VydGlmaWNhdGUxQzBBBgNVBAsMOm1hcmNvQE1hcmNvcy1NYWNCb29rLVBy
-by5sb2NhbCAoTWFyY28gQ2FzdGlsbG8gRGVsbGEgU2VyYSkwggEiMA0GCSqGSIb3
-DQEBAQUAA4IBDwAwggEKAoIBAQDNjfXRKBwXU0IHftJJGiR5w6Ccf2JfPZJgDdar
-hVgJjL2cy9d4AwIq4ydiuU+H8MnguzdGrFaCgYOBGfgEI4dOAGr1AInRVVHRWKvw
-GdLYm59dBRi5PQuU2EKVonQNsZy/qcOJSBzBSSAxPFCpTwrxj0j/Dug6LxIa1wB7
-UenYn5NjkFSF8F5HufE7l4goIVh0/fVgRripCsnkiMQFVhMr+2glX+19zTVkBl9E
-tAPbkXsegUUdnkOH2sd1TBN4HUibnktX+P1aIlhdp741Eni42jU92u33iZasvvnk
-A94Q2MhBhzx3lgqAAcHcePzBI9yOEQbTqik4NkpvmoqqDFBbAgMBAAGjdjB0MA4G
-A1UdDwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDATAfBgNVHSMEGDAWgBTN
-imcw8dRZ+LdM83iq2xnhRgHVMjAsBgNVHREEJTAjgglsb2NhbGhvc3SHBH8AAAGH
-EAAAAAAAAAAAAAAAAAAAAAEwDQYJKoZIhvcNAQELBQADggGBAIA2HiGT0dtdkNfB
-LFAIUvlatqHkH4Pds3jd0TnT4muoebPoHc3HSoqnSdt4g2vN+75S47G7E5b/qQbH
-ZfkL9kgZoCar79DuVpC/kCPI/NACRsqdgIcnd09FqN2Dmg1UP2F/nulLucWfOiSL
-T3q3nVEAm3UL4R5VopFW94bp8jJ/cWseDohIGZBza4yUiMnbd6mK+g+DoExfGbwc
-A3601xeDWcDxKv+KaBWQeyoUWO66FKYOJcdwaiPCPrvXVz3tdbxBpHB/beNeulaU
-6EzDRCmtIwEZNwq9MNn0wViOjta1TtkeERtbvnmgPmFhhSbHDtGbbxuwWnV91aZg
-0JFymKsmmBIv4Qu50zVPo7Jz0n6CucIPVUW8ZoamVBr6ljHOfZIg9N0hkRoX7DUT
-pPV22KliCRZCHYnyVcIzwtW2lxlzydUnldhxZga6vlfoKR5WzCceTtsX2+p8dbJe
-p5jVRsLyT/sfECb8n5N7BYRLSh36FekFGErFCr9Svqd9pRVsWg==
------END CERTIFICATE-----

package/proto/workflow.proto

@@ -1,33 +0,0 @@
-syntax = "proto3";
-
-package blok.workflow.v1;
-
-message WorkflowRequest {
-    string Name = 1;
-    string Message = 2;
-    string Encoding = 3;
-    string Type = 4;
-}
-
-message WorkflowResponse {
-    string Message = 1;
-    string Encoding = 2;
-    string Type = 3;
-}
-
-enum MessageEncoding {
-    BASE64 = 0;
-    STRING = 1;
-}
-
-enum MessageType {
-    TEXT = 0;
-    JSON = 1;
-    XML = 2;
-    HTML = 3;
-    BINARY = 4;
-}
-
-service WorkflowService {
-    rpc ExecuteWorkflow (WorkflowRequest) returns (WorkflowResponse) {}
-}

package/src/GRpcTrigger.ts

@@ -1,265 +0,0 @@
-import {
-	DefaultLogger,
-	type GlobalOptions,
-	NodeMap,
-	type ParamsDictionary,
-	TriggerBase,
-	type TriggerResponse,
-} from "@blokjs/runner";
-import { type Context, GlobalError } from "@blokjs/shared";
-import type { ConnectRouter } from "@connectrpc/connect";
-import { type Span, SpanStatusCode, metrics, trace } from "@opentelemetry/api";
-import fastify from "fastify";
-import { v4 as uuid } from "uuid";
-import MessageDecode from "./MessageDecode";
-import nodes from "./Nodes";
-import workflows from "./Workflows";
-import type RuntimeWorkflow from "./types/RuntimeWorkflow";
-
-import { type Step, Workflow } from "@blokjs/helper";
-import type { TriggerOpts } from "@blokjs/helper/dist/types/TriggerOpts";
-import {
-	MessageEncoding,
-	MessageType,
-	type WorkflowRequest,
-	type WorkflowResponse,
-	WorkflowService,
-} from "./gen/workflow_pb";
-
-enum NodeTypes {
-	MODULE = "module",
-	LOCAL = "local",
-	PYTHON3 = "runtime.python3",
-}
-
-export default class GRpcTrigger extends TriggerBase {
-	private server = fastify({
-		http2: true,
-		// https: {
-		//     key: readFileSync("localhost+2-key.pem", "utf8"),
-		//     cert: readFileSync("localhost+2.pem", "utf8"),
-		// }
-	});
-	private nodeMap: GlobalOptions = <GlobalOptions>{};
-	protected tracer = trace.getTracer(
-		process.env.PROJECT_NAME || "trigger-grpc-workflow",
-		process.env.PROJECT_VERSION || "0.0.1",
-	);
-	private logger = new DefaultLogger();
-
-	constructor() {
-		super();
-		this.loadNodes();
-		this.loadWorkflows();
-	}
-
-	getApp() {
-		return this.server;
-	}
-
-	async listen(): Promise<number> {
-		return 0;
-	}
-
-	loadNodes() {
-		this.nodeMap.nodes = new NodeMap();
-		const nodeKeys = Object.keys(nodes);
-		for (const key of nodeKeys) {
-			this.nodeMap.nodes.addNode(key, nodes[key]);
-		}
-	}
-
-	loadWorkflows() {
-		this.nodeMap.workflows = workflows;
-	}
-
-	processRequest(router: ConnectRouter, trigger: GRpcTrigger) {
-		router.service(WorkflowService, {
-			executeWorkflow: (request: WorkflowRequest) => trigger.executeWorkflow(request),
-		});
-	}
-
-	async executeWorkflow(request: WorkflowRequest) {
-		const start = performance.now();
-		const coder = new MessageDecode();
-		let name = request.Name;
-		const messageContext: Context = coder.requestDecode(request);
-		const runtimeWorkflow = messageContext as unknown as RuntimeWorkflow;
-		const id: string = (messageContext.request.query?.requestId as string) || (uuid() as string);
-		let remoteNodeExecution = false;
-
-		const defaultMeter = metrics.getMeter("default");
-		const workflow_runner_errors = defaultMeter.createCounter("workflow_errors", {
-			description: "Workflow runner errors",
-		});
-
-		return await this.tracer.startActiveSpan(`${name}`, async (span: Span) => {
-			try {
-				if (runtimeWorkflow !== undefined) {
-					const workflowModel = runtimeWorkflow.workflow;
-					const node_type = (workflowModel.steps[0] as unknown as ParamsDictionary).type;
-					let set_node_type: NodeTypes = NodeTypes.MODULE;
-					switch (node_type) {
-						case "runtime.python3":
-							set_node_type = NodeTypes.PYTHON3;
-							break;
-						case "local":
-							set_node_type = NodeTypes.LOCAL;
-							break;
-						default:
-							set_node_type = NodeTypes.MODULE;
-							break;
-					}
-
-					const trigger = Object.keys(workflowModel.trigger)[0];
-					const trigger_config =
-						((workflowModel.trigger as unknown as ParamsDictionary)[trigger] as unknown as TriggerOpts) || {};
-
-					const step: Step = Workflow({
-						name: `Remote Node: ${name}`,
-						version: "1.0.0",
-						description: "Remote Node",
-					})
-						.addTrigger((trigger as unknown as "http") || "grpc", trigger_config)
-						.addStep({
-							name: "node",
-							node: name,
-							type: set_node_type,
-							inputs: ((workflowModel.nodes as unknown as ParamsDictionary).node as unknown as ParamsDictionary).inputs,
-						});
-
-					this.nodeMap.workflows[id] = step;
-					name = id;
-					remoteNodeExecution = true;
-				}
-
-				await this.configuration.init(name, this.nodeMap);
-				let ctx: Context = this.createContext(undefined, name, id);
-				ctx.request = messageContext.request;
-				ctx.logger.log(`Workflow: ${name}, Version: ${this.configuration.version}`);
-
-				const response: TriggerResponse = await this.run(ctx);
-				ctx = response.ctx;
-				const average = response.metrics;
-
-				// Support both module nodes (wrapped BlokResponse with .data/.contentType)
-				// and runtime adapter nodes (raw data without wrapper)
-				const hasWrapper =
-					ctx.response && typeof ctx.response === "object" && "data" in ctx.response && "contentType" in ctx.response;
-				if (!hasWrapper) {
-					// Runtime adapter node: ctx.response is raw data, wrap it
-					ctx.response = {
-						data: ctx.response,
-						contentType: "application/json",
-						success: true,
-						error: null,
-					} as typeof ctx.response;
-				}
-				if (ctx.response.contentType === undefined || ctx.response.contentType === "")
-					ctx.response.contentType = "application/json";
-
-				const end = performance.now();
-				ctx.logger.log(`Completed in ${(end - start).toFixed(2)}ms`);
-
-				span.setAttribute("success", true);
-				span.setAttribute("Content-Type", ctx.response.contentType as string);
-				span.setAttribute("workflow_request_id", `${ctx.id}`);
-				span.setAttribute("workflow_elapsed_time", `${end - start}`);
-				span.setAttribute("workflow_version", `${this.configuration.version}`);
-				span.setAttribute("workflow_name", `${this.configuration.name}`);
-				span.setAttribute("workflow_memory_avg_mb", `${average.memory.total}`);
-				span.setAttribute("workflow_memory_min_mb", `${average.memory.min}`);
-				span.setAttribute("workflow_memory_max_mb", `${average.memory.max}`);
-				span.setAttribute("workflow_cpu_percentage", `${average.cpu.average}`);
-				span.setAttribute("workflow_cpu_total", `${average.cpu.total}`);
-				span.setAttribute("workflow_cpu_usage", `${average.cpu.usage}`);
-				span.setAttribute("workflow_cpu_model", `${average.cpu.model}`);
-				span.setStatus({ code: SpanStatusCode.OK });
-
-				return coder.responseEncode(ctx, request.Encoding, request.Type);
-			} catch (e: unknown) {
-				span.setAttribute("success", false);
-				span.setAttribute("workflow_request_id", `${id}`);
-				span.recordException(e as Error);
-				let message: WorkflowResponse = <WorkflowResponse>{};
-				const base64Key = MessageEncoding[MessageEncoding.BASE64];
-				const textKey = MessageType[MessageType.TEXT];
-				const jsonKey = MessageType[MessageType.JSON];
-
-				if (e instanceof GlobalError) {
-					const error_context = e as GlobalError;
-
-					if (error_context.context.message === "{}" && error_context.context.json instanceof DOMException) {
-						workflow_runner_errors.add(1, {
-							env: process.env.NODE_ENV,
-							workflow_version: `${this.configuration.version || "unknown"}`,
-							workflow_name: `${name || this.configuration.name}`,
-						});
-						span.setStatus({
-							code: SpanStatusCode.ERROR,
-							message: (error_context.context.json as Error).toString(),
-						});
-
-						this.logger.error(`${(error_context.context.json as Error).toString()}`);
-						message = {
-							Message: coder.responseErrorEncode((error_context.context.json as Error).toString(), base64Key, textKey),
-							Encoding: base64Key,
-							Type: textKey,
-						} as WorkflowResponse;
-					} else {
-						if (error_context.context.code === undefined) error_context.setCode(500);
-
-						if (error_context.hasJson()) {
-							workflow_runner_errors.add(1, {
-								env: process.env.NODE_ENV,
-								workflow_version: `${this.configuration.version || "unknown"}`,
-								workflow_name: `${name || this.configuration.name}`,
-							});
-							span.setStatus({ code: SpanStatusCode.ERROR, message: JSON.stringify(error_context.context.json) });
-							this.logger.error(`${JSON.stringify(error_context.context.json)}`);
-							message = {
-								Message: coder.responseErrorEncode(JSON.stringify(error_context.context.json), base64Key, textKey),
-								Encoding: base64Key,
-								Type: jsonKey,
-							} as WorkflowResponse;
-						} else {
-							workflow_runner_errors.add(1, {
-								env: process.env.NODE_ENV,
-								workflow_version: `${this.configuration.version || "unknown"}`,
-								workflow_name: `${name || this.configuration.name}`,
-							});
-							span.setStatus({ code: SpanStatusCode.ERROR, message: error_context.message });
-							this.logger.error(`${error_context.message}`, error_context.stack?.replace(/\n/g, " "));
-							message = {
-								Message: coder.responseErrorEncode(error_context.message, base64Key, textKey),
-								Encoding: MessageEncoding[MessageEncoding.BASE64],
-								Type: textKey,
-							} as WorkflowResponse;
-						}
-					}
-				} else {
-					workflow_runner_errors.add(1, {
-						env: process.env.NODE_ENV,
-						workflow_version: `${this.configuration.version || "unknown"}`,
-						workflow_name: `${name || this.configuration.name}`,
-					});
-					span.setStatus({ code: SpanStatusCode.ERROR, message: (e as Error).message });
-					this.logger.error(`${(e as Error).message}`, `${(e as Error).stack?.replace(/\n/g, " ")}`);
-
-					message = {
-						Message: coder.responseErrorEncode((e as Error).message, base64Key, textKey),
-						Encoding: base64Key,
-						Type: textKey,
-					} as WorkflowResponse;
-				}
-
-				return message;
-			} finally {
-				if (remoteNodeExecution) {
-					delete this.nodeMap.workflows[id];
-				}
-				span.end();
-			}
-		});
-	}
-}

package/src/GrpcClient.ts

@@ -1,87 +0,0 @@
-import { type Transport, createClient } from "@connectrpc/connect";
-import { createGrpcTransport } from "@connectrpc/connect-node";
-import { createConnectTransport } from "@connectrpc/connect-node";
-import { createGrpcWebTransport } from "@connectrpc/connect-node";
-import { type WorkflowRequest, type WorkflowResponse, WorkflowService } from "./gen/workflow_pb";
-
-export type RpcOptions = {
-	host: string;
-	port: number;
-	protocol: string;
-	httpVersion: HttpVersionEnum;
-	transport: TransportEnum;
-};
-
-export type CallOptions = {
-	headers: Record<string, string>;
-};
-
-export enum TransportEnum {
-	GRPC = "grpc",
-	GRPC_WEB = "grpc-web",
-	CONNECT = "connect",
-}
-
-export enum HttpVersionEnum {
-	HTTP1 = "1.1",
-	HTTP2 = "2",
-}
-
-export type { WorkflowRequest, WorkflowResponse };
-
-export default class GrpcClient {
-	protected opts: RpcOptions;
-
-	constructor(options: RpcOptions) {
-		this.opts = options;
-	}
-
-	async call(message: WorkflowRequest, opts?: CallOptions): Promise<WorkflowResponse> {
-		const transport = this.transport();
-		const client = createClient(WorkflowService, transport);
-		return await client.executeWorkflow(message, opts);
-	}
-
-	transport(): Transport {
-		switch (this.opts.transport) {
-			case TransportEnum.GRPC:
-				return createGrpcTransport({
-					baseUrl: `${this.opts.protocol}://${this.opts.host}:${this.opts.port}/`,
-					interceptors: [],
-				});
-			case TransportEnum.GRPC_WEB:
-				return createGrpcWebTransport({
-					baseUrl: `${this.opts.protocol}://${this.opts.host}:${this.opts.port}/`,
-					httpVersion: this.opts.httpVersion,
-					interceptors: [],
-				});
-			case TransportEnum.CONNECT:
-				return createConnectTransport({
-					baseUrl: `${this.opts.protocol}://${this.opts.host}:${this.opts.port}/`,
-					httpVersion: this.opts.httpVersion,
-					interceptors: [],
-				});
-			default:
-				throw new Error("Invalid transport type");
-		}
-	}
-}
-
-// let client = new GrpcClient({
-//     host: "localhost",
-//     port: 8433,
-//     protocol: "http",
-//     httpVersion: HttpVersionEnum.HTTP2,
-//     transport: TransportEnum.GRPC,
-// });
-
-// client.call({
-//     "Name": "countries",
-//     "Message": "ewogICAgInJlcXVlc3QiOiB7CiAgICAgICAgImJvZHkiOiB7CiAgICAgICAgICAgICJjb3VudHJ5X25hbWUiOiAiQ2FuYWRhIgogICAgICAgIH0KICAgIH0KfQ==",
-//     "Encoding": "BASE64",
-//     "Type": "JSON"
-// } as WorkflowRequest).then((response) => {
-//     console.log(response);
-// }).catch((error) => {
-//     console.error(error);
-// });