@blokjs/shared 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,69 @@
+# @blokjs/shared
+
+## 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
+
+## 0.0.9
+
+### Patch Changes
+
+- Python3 runtime implemented in the runner
+
+## 0.0.8
+
+### 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')
+
+## 0.0.7
+
+### Patch Changes
+
+- Added support for YAML, XML and TOML in the workflow file. Upgraded package version recommended by Dependabot.
+
+## 0.0.6
+
+### Patch Changes
+
+- Updated the quickstart mdx and fixed api-call error issue with rest
+
+## 0.0.5
+
+### Patch Changes
+
+- Implemented a react node and the chatbot demo page
+
+## 0.0.4
+
+### Patch Changes
+
+- Improved Loki metrics
+
+## 0.0.3
+
+### Patch Changes
+
+- Improved and extended the open telemetry feature
+
+## 0.0.2
+
+### Patch Changes
+
+- Fixed open telemetry issues and types
+
+## 0.0.1
+
+### Patch Changes
+
+- Fixed issue with the cli node creation test

package/__tests__/unit/GlobalError.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest";
+import GlobalError from "../../src/GlobalError";
+
+describe("GlobalError", () => {
+	describe("constructor", () => {
+		it("should create error with message string", () => {
+			const error = new GlobalError("test error");
+			expect(error.message).toBe("test error");
+			expect(error.context.message).toBe("test error");
+		});
+
+		it("should extend Error", () => {
+			const error = new GlobalError("test");
+			expect(error).toBeInstanceOf(Error);
+		});
+
+		it("should set prototype correctly for instanceof", () => {
+			const error = new GlobalError("test");
+			expect(error).toBeInstanceOf(GlobalError);
+		});
+
+		it("should handle undefined message", () => {
+			const error = new GlobalError(undefined);
+			expect(error.context.message).toBeUndefined();
+		});
+	});
+
+	describe("setCode", () => {
+		it("should set code on context", () => {
+			const error = new GlobalError("test");
+			error.setCode(404);
+			expect(error.context.code).toBe(404);
+		});
+
+		it("should handle undefined code", () => {
+			const error = new GlobalError("test");
+			error.setCode(undefined);
+			expect(error.context.code).toBeUndefined();
+		});
+	});
+
+	describe("setJson", () => {
+		it("should set json on context", () => {
+			const json = { key: "value" };
+			const error = new GlobalError("test");
+			error.setJson(json);
+			expect(error.context.json).toEqual(json);
+		});
+	});
+
+	describe("setStack", () => {
+		it("should set stack on context", () => {
+			const error = new GlobalError("test");
+			error.setStack("Error\n  at test.ts:1");
+			expect(error.context.stack).toBe("Error\n  at test.ts:1");
+		});
+	});
+
+	describe("setName", () => {
+		it("should set name on context", () => {
+			const error = new GlobalError("test");
+			error.setName("my-node");
+			expect(error.context.name).toBe("my-node");
+		});
+	});
+
+	describe("hasJson", () => {
+		it("should return false when no json set", () => {
+			const error = new GlobalError("test");
+			expect(error.hasJson()).toBe(false);
+		});
+
+		it("should return true when json is set", () => {
+			const error = new GlobalError("test");
+			error.setJson({ key: "value" });
+			expect(error.hasJson()).toBe(true);
+		});
+	});
+
+	describe("toString", () => {
+		it("should return JSON string when json is set", () => {
+			const error = new GlobalError("test");
+			const json = { key: "value" };
+			error.setJson(json);
+			expect(error.toString()).toBe(JSON.stringify(json));
+		});
+
+		it("should return message string when no json", () => {
+			const error = new GlobalError("test error");
+			expect(error.toString()).toBe("test error");
+		});
+	});
+});

package/__tests__/unit/GlobalLogger.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import GlobalLogger from "../../src/GlobalLogger";
+
+class TestLogger extends GlobalLogger {
+	log(message: string): void {
+		this.logs.push(message);
+	}
+
+	logLevel(level: string, message: string): void {
+		this.logs.push(`[${level}] ${message}`);
+	}
+
+	error(message: string, stack: string): void {
+		this.logs.push(`ERROR: ${message} - ${stack}`);
+	}
+}
+
+describe("GlobalLogger", () => {
+	it("should initialize with empty logs array", () => {
+		const logger = new TestLogger();
+		expect(logger.getLogs()).toEqual([]);
+	});
+
+	describe("getLogs", () => {
+		it("should return logs after logging", () => {
+			const logger = new TestLogger();
+			logger.log("msg1");
+			logger.log("msg2");
+			expect(logger.getLogs()).toEqual(["msg1", "msg2"]);
+		});
+	});
+
+	describe("getLogsAsText", () => {
+		it("should join logs with newline", () => {
+			const logger = new TestLogger();
+			logger.log("line1");
+			logger.log("line2");
+			expect(logger.getLogsAsText()).toBe("line1\nline2");
+		});
+
+		it("should return empty string for no logs", () => {
+			const logger = new TestLogger();
+			expect(logger.getLogsAsText()).toBe("");
+		});
+	});
+
+	describe("getLogsAsBase64", () => {
+		it("should return base64 encoded logs", () => {
+			const logger = new TestLogger();
+			logger.log("hello");
+			const expected = Buffer.from("hello").toString("base64");
+			expect(logger.getLogsAsBase64()).toBe(expected);
+		});
+
+		it("should return base64 of empty string for no logs", () => {
+			const logger = new TestLogger();
+			const expected = Buffer.from("").toString("base64");
+			expect(logger.getLogsAsBase64()).toBe(expected);
+		});
+	});
+
+	describe("logLevel", () => {
+		it("should format with level prefix", () => {
+			const logger = new TestLogger();
+			logger.logLevel("WARN", "something happened");
+			expect(logger.getLogs()).toEqual(["[WARN] something happened"]);
+		});
+	});
+
+	describe("error", () => {
+		it("should format error with stack", () => {
+			const logger = new TestLogger();
+			logger.error("fail", "stack trace");
+			expect(logger.getLogs()).toEqual(["ERROR: fail - stack trace"]);
+		});
+	});
+});

package/__tests__/unit/Metrics.test.ts

@@ -0,0 +1,77 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { Metrics } from "../../src/Metrics";
+
+describe("Metrics", () => {
+	let metrics: Metrics;
+
+	beforeEach(() => {
+		metrics = new Metrics();
+	});
+
+	it("should construct without errors", () => {
+		expect(metrics).toBeDefined();
+	});
+
+	describe("start()", () => {
+		it("should call start on all sub-metrics without error", () => {
+			expect(() => metrics.start()).not.toThrow();
+		});
+	});
+
+	describe("stop()", () => {
+		it("should call stop without error after start", () => {
+			metrics.start();
+			expect(() => metrics.stop()).not.toThrow();
+		});
+	});
+
+	describe("retry()", () => {
+		it("should call start on memoryUsage only", () => {
+			metrics.start();
+			expect(() => metrics.retry()).not.toThrow();
+		});
+	});
+
+	describe("clear()", () => {
+		it("should clear memory usage values", () => {
+			metrics.start();
+			metrics.clear();
+			// After clear, memory metrics should be zeroed
+			const result = metrics.getMetrics();
+			expect(result.memory.min).toBe(0);
+			expect(result.memory.max).toBe(0);
+		});
+	});
+
+	describe("getMetrics()", () => {
+		it("should return object with cpu, memory, time", () => {
+			metrics.start();
+			metrics.stop();
+
+			const result = metrics.getMetrics();
+			expect(result).toHaveProperty("cpu");
+			expect(result).toHaveProperty("memory");
+			expect(result).toHaveProperty("time");
+		});
+
+		it("should return valid metric shapes after start/stop cycle", () => {
+			metrics.start();
+			metrics.stop();
+
+			const result = metrics.getMetrics();
+			// CPU
+			expect(result.cpu).toHaveProperty("total");
+			expect(result.cpu).toHaveProperty("average");
+			expect(result.cpu).toHaveProperty("usage");
+			expect(result.cpu).toHaveProperty("model");
+			// Memory
+			expect(result.memory).toHaveProperty("total");
+			expect(result.memory).toHaveProperty("min");
+			expect(result.memory).toHaveProperty("max");
+			// Time
+			expect(result.time).toHaveProperty("startTime");
+			expect(result.time).toHaveProperty("endTime");
+			expect(result.time).toHaveProperty("duration");
+		});
+	});
+});

package/__tests__/unit/NodeBase.test.ts

@@ -0,0 +1,286 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import GlobalError from "../../src/GlobalError";
+import NodeBase from "../../src/NodeBase";
+import type Context from "../../src/types/Context";
+import type ResponseContext from "../../src/types/ResponseContext";
+
+class TestNode extends NodeBase {
+	public mockResponse: ResponseContext = { data: { result: "ok" }, error: null, success: true };
+	public runCalls: Context[] = [];
+
+	async run(ctx: Context): Promise<ResponseContext> {
+		this.runCalls.push(ctx);
+		return this.mockResponse;
+	}
+}
+
+function createTestContext(overrides: Partial<Context> = {}): Context {
+	return {
+		id: "test-ctx",
+		request: { body: {}, headers: {}, query: {}, params: {} },
+		response: { data: null, error: null, success: true },
+		error: { message: "" },
+		logger: { log: vi.fn(), logLevel: vi.fn(), error: vi.fn() },
+		config: {},
+		func: {},
+		vars: {},
+		eventLogger: null,
+		_PRIVATE_: null,
+		...overrides,
+	} as Context;
+}
+
+describe("NodeBase", () => {
+	let node: TestNode;
+
+	beforeEach(() => {
+		node = new TestNode();
+		node.name = "test-node";
+		vi.restoreAllMocks();
+	});
+
+	describe("default properties", () => {
+		it("should have correct defaults", () => {
+			const n = new TestNode();
+			expect(n.flow).toBe(false);
+			expect(n.name).toBe("");
+			expect(n.active).toBe(true);
+			expect(n.stop).toBe(false);
+			expect(n.set_var).toBe(false);
+			expect(n.contentType).toBe("");
+		});
+	});
+
+	describe("process()", () => {
+		it("should call run() and return response", async () => {
+			const ctx = createTestContext({
+				config: { "test-node": { param: "value" } },
+			});
+
+			const response = await node.process(ctx);
+			expect(response).toEqual(node.mockResponse);
+			expect(node.runCalls).toHaveLength(1);
+		});
+
+		it("should clone config for originalConfig", async () => {
+			const configData = { key: "val" };
+			const ctx = createTestContext({
+				config: { "test-node": configData },
+			});
+
+			await node.process(ctx);
+			expect(node.originalConfig).toEqual(configData);
+			// Should be a deep clone, not same reference
+			expect(node.originalConfig).not.toBe(configData);
+		});
+
+		it("should set ctx.response on success", async () => {
+			const ctx = createTestContext({
+				config: { "test-node": {} },
+			});
+
+			await node.process(ctx);
+			expect(ctx.response).toEqual(node.mockResponse);
+		});
+
+		it("should throw when response has error", async () => {
+			const error = new GlobalError("process error");
+			node.mockResponse = { data: null, error, success: false };
+
+			const ctx = createTestContext({
+				config: { "test-node": {} },
+			});
+
+			await expect(node.process(ctx)).rejects.toBe(error);
+		});
+	});
+
+	describe("processFlow()", () => {
+		it("should call run() and return response", async () => {
+			const ctx = createTestContext({
+				config: { "test-node": {} },
+			});
+
+			const response = await node.processFlow(ctx);
+			expect(response).toEqual(node.mockResponse);
+		});
+
+		it("should catch errors and wrap in setError", async () => {
+			const testNode = new TestNode();
+			testNode.name = "error-node";
+			testNode.run = vi.fn().mockRejectedValue({ message: "oops" });
+
+			const ctx = createTestContext({
+				config: { "error-node": {} },
+			});
+
+			const response = await testNode.processFlow(ctx);
+			expect(response.success).toBe(false);
+			expect(response.error).toBeInstanceOf(GlobalError);
+		});
+
+		it("should set ctx.response on error", async () => {
+			const testNode = new TestNode();
+			testNode.name = "error-node";
+			testNode.run = vi.fn().mockRejectedValue({ message: "fail" });
+
+			const ctx = createTestContext({
+				config: { "error-node": {} },
+			});
+
+			await testNode.processFlow(ctx);
+			expect(ctx.response.success).toBe(false);
+			expect(ctx.response.error).toBeInstanceOf(GlobalError);
+		});
+	});
+
+	describe("runSteps()", () => {
+		it('should throw "not implemented" error', () => {
+			const ctx = createTestContext();
+			const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+			expect(() => node.runSteps([], ctx)).toThrow("runSteps method is not implemented.");
+			consoleSpy.mockRestore();
+		});
+	});
+
+	describe("runJs()", () => {
+		it("should evaluate simple expressions", () => {
+			const ctx = createTestContext();
+			const result = node.runJs("1 + 2", ctx);
+			expect(result).toBe(3);
+		});
+
+		it("should access ctx parameter", () => {
+			const ctx = createTestContext({ id: "my-id" });
+			const result = node.runJs("ctx.id", ctx);
+			expect(result).toBe("my-id");
+		});
+
+		it("should access data parameter", () => {
+			const ctx = createTestContext();
+			const result = node.runJs("data.x", ctx, { x: 42 });
+			expect(result).toBe(42);
+		});
+
+		it("should access vars parameter", () => {
+			const ctx = createTestContext();
+			const result = node.runJs("vars.count", ctx, {}, {}, { count: 10 });
+			expect(result).toBe(10);
+		});
+
+		it("should handle string concatenation", () => {
+			const ctx = createTestContext();
+			const result = node.runJs('"hello" + " " + "world"', ctx);
+			expect(result).toBe("hello world");
+		});
+	});
+
+	describe("setVar()", () => {
+		it("should initialize ctx.vars if undefined", () => {
+			const ctx = createTestContext();
+			ctx.vars = undefined;
+			node.setVar(ctx, { key: "value" });
+			expect(ctx.vars).toEqual({ key: "value" });
+		});
+
+		it("should merge vars into ctx.vars", () => {
+			const ctx = createTestContext({ vars: { existing: "keep" } });
+			node.setVar(ctx, { newKey: "newVal" });
+			expect(ctx.vars).toEqual({ existing: "keep", newKey: "newVal" });
+		});
+	});
+
+	describe("getVar()", () => {
+		it("should return value by name", () => {
+			const ctx = createTestContext({ vars: { myVar: "found" } });
+			expect(node.getVar(ctx, "myVar")).toBe("found");
+		});
+
+		it("should return undefined for missing var", () => {
+			const ctx = createTestContext({ vars: { a: 1 } });
+			expect(node.getVar(ctx, "nonexistent")).toBeUndefined();
+		});
+
+		it("should handle undefined ctx.vars", () => {
+			const ctx = createTestContext();
+			ctx.vars = undefined;
+			expect(node.getVar(ctx, "any")).toBeUndefined();
+		});
+	});
+
+	describe("blueprintMapper()", () => {
+		it("should handle string input", () => {
+			const ctx = createTestContext();
+			const result = node.blueprintMapper("plain text", ctx);
+			expect(result).toBe("plain text");
+		});
+
+		it("should handle object input without error", () => {
+			const ctx = createTestContext();
+			const obj = { key: "value" };
+			const result = node.blueprintMapper(obj, ctx);
+			expect(result).toEqual(obj);
+		});
+
+		it("should catch and log mapper errors", () => {
+			const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+			const ctx = createTestContext();
+			// null will cause mapper to fail
+			const result = node.blueprintMapper(null as unknown as Record<string, unknown>, ctx);
+			// Should not throw
+			expect(result).toBeNull();
+			consoleSpy.mockRestore();
+		});
+	});
+
+	describe("setError()", () => {
+		it("should create GlobalError from string", () => {
+			const error = node.setError("simple error" as unknown as any);
+			expect(error).toBeInstanceOf(GlobalError);
+			expect(error.message).toBe("simple error");
+		});
+
+		it("should create GlobalError from {message} only", () => {
+			const error = node.setError({ message: "just a message" });
+			expect(error).toBeInstanceOf(GlobalError);
+			expect(error.message).toBe("just a message");
+		});
+
+		it("should create GlobalError from object with multiple keys", () => {
+			const config = { message: "error", detail: "extra info" };
+			const error = node.setError(config as any);
+			expect(error).toBeInstanceOf(GlobalError);
+			expect(error.hasJson()).toBe(true);
+		});
+
+		it("should set json when config has json field", () => {
+			const config = { message: "err", json: { detail: "info" } };
+			const error = node.setError(config as any);
+			expect(error.hasJson()).toBe(true);
+		});
+
+		it("should set stack when config has stack field", () => {
+			const config = { message: "err", stack: "Error\n  at line 1" };
+			const error = node.setError(config);
+			expect(error.context.stack).toBe("Error\n  at line 1");
+		});
+
+		it("should set numeric code from config", () => {
+			const config = { message: "err", code: 404 };
+			const error = node.setError(config);
+			expect(error.context.code).toBe(404);
+		});
+
+		it("should default to 500 for non-numeric code", () => {
+			const config = { message: "err", code: "bad" as unknown as number };
+			const error = node.setError(config);
+			expect(error.context.code).toBe(500);
+		});
+
+		it("should set name from this.name", () => {
+			const error = node.setError({ message: "err" });
+			expect(error.context.name).toBe("test-node");
+		});
+	});
+});

package/__tests__/unit/Trigger.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import Trigger from "../../src/Trigger";
+
+class TestTrigger extends Trigger {
+	public listenCalled = false;
+
+	listen(): void {
+		this.listenCalled = true;
+	}
+}
+
+describe("Trigger", () => {
+	it("should allow concrete subclass to implement listen()", () => {
+		const trigger = new TestTrigger();
+		trigger.listen();
+		expect(trigger.listenCalled).toBe(true);
+	});
+
+	it("should be an instance of Trigger", () => {
+		const trigger = new TestTrigger();
+		expect(trigger).toBeInstanceOf(Trigger);
+	});
+});