@blokjs/shared 0.2.0

package/__tests__/unit/utils/CpuUsage.test.ts

@@ -0,0 +1,102 @@
+import os from "node:os";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import CpuMetrics from "../../../src/utils/CpuUsage";
+
+const mockCpuInfo = (idle: number, user: number, sys: number) => [
+	{
+		model: "Test CPU Model",
+		speed: 2400,
+		times: { idle, user, sys, nice: 0, irq: 0 },
+	},
+	{
+		model: "Test CPU Model",
+		speed: 2400,
+		times: { idle, user, sys, nice: 0, irq: 0 },
+	},
+];
+
+describe("CpuMetrics", () => {
+	let cpu: CpuMetrics;
+
+	beforeEach(() => {
+		cpu = new CpuMetrics();
+		vi.restoreAllMocks();
+	});
+
+	describe("start()", () => {
+		it("should capture CPU info (model and count)", () => {
+			vi.spyOn(os, "cpus").mockReturnValue(mockCpuInfo(1000, 500, 200) as os.CpuInfo[]);
+			cpu.start();
+			const metrics = cpu.getMetrics();
+			expect(metrics.model).toBe("Test CPU Model");
+			expect(metrics.total).toBe(2);
+		});
+	});
+
+	describe("stop()", () => {
+		it("should capture end usage without error", () => {
+			vi.spyOn(os, "cpus").mockReturnValue(mockCpuInfo(1000, 500, 200) as os.CpuInfo[]);
+			cpu.start();
+			cpu.stop();
+			// Should not throw
+			expect(true).toBe(true);
+		});
+	});
+
+	describe("getAverage()", () => {
+		it("should calculate CPU percentage between start and stop", () => {
+			const startCpus = mockCpuInfo(1000, 500, 200);
+			const stopCpus = mockCpuInfo(1050, 550, 250);
+
+			vi.spyOn(os, "cpus")
+				.mockReturnValueOnce(startCpus as os.CpuInfo[]) // start -> constructor call
+				.mockReturnValueOnce(startCpus as os.CpuInfo[]) // start -> measureCpu
+				.mockReturnValueOnce(stopCpus as os.CpuInfo[]) // stop -> measureCpu
+				.mockReturnValueOnce(stopCpus as os.CpuInfo[]); // potential extra
+
+			cpu.start();
+			cpu.stop();
+
+			const metrics = cpu.getMetrics();
+			expect(metrics.average).toBeTypeOf("number");
+			expect(metrics.average).toBeGreaterThanOrEqual(0);
+			expect(metrics.average).toBeLessThanOrEqual(100);
+		});
+	});
+
+	describe("getMetrics()", () => {
+		it("should return correct shape with total, average, usage, model", () => {
+			vi.spyOn(os, "cpus").mockReturnValue(mockCpuInfo(1000, 500, 200) as os.CpuInfo[]);
+			cpu.start();
+			cpu.stop();
+
+			const metrics = cpu.getMetrics();
+			expect(metrics).toHaveProperty("total");
+			expect(metrics).toHaveProperty("average");
+			expect(metrics).toHaveProperty("usage");
+			expect(metrics).toHaveProperty("model");
+		});
+	});
+
+	describe("measureCpu()", () => {
+		it("should return idle, total, model, cpus shape", () => {
+			vi.spyOn(os, "cpus").mockReturnValue(mockCpuInfo(1000, 500, 200) as os.CpuInfo[]);
+			const result = cpu.measureCpu();
+			expect(result).toHaveProperty("idle");
+			expect(result).toHaveProperty("total");
+			expect(result).toHaveProperty("model");
+			expect(result).toHaveProperty("cpus");
+			expect(result.cpus).toBe(2);
+		});
+
+		it("should aggregate across all CPU cores", () => {
+			vi.spyOn(os, "cpus").mockReturnValue(mockCpuInfo(1000, 500, 200) as os.CpuInfo[]);
+			const result = cpu.measureCpu();
+			// idle is averaged: (1000 + 1000) / 2 = 1000
+			expect(result.idle).toBe(1000);
+			// total per core: idle + irq + nice + sys + user = 1000 + 0 + 0 + 200 + 500 = 1700
+			// averaged: (1700 + 1700) / 2 = 1700
+			expect(result.total).toBe(1700);
+		});
+	});
+});

package/__tests__/unit/utils/Mapper.test.ts

@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type Context from "../../../src/types/Context";
+import mapper from "../../../src/utils/Mapper";
+
+function createMockContext(overrides: Partial<Context> = {}): Context {
+	return {
+		id: "test-id",
+		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("Mapper", () => {
+	beforeEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	describe("replaceString()", () => {
+		it("should replace ${key} with data value", () => {
+			const ctx = createMockContext();
+			const data = { name: "John" };
+			const result = mapper.replaceString("Hello ${name}", ctx, data);
+			expect(result).toBe("Hello John");
+		});
+
+		it("should replace multiple placeholders", () => {
+			const ctx = createMockContext();
+			const data = { first: "John", last: "Doe" };
+			const result = mapper.replaceString("${first} ${last}", ctx, data);
+			expect(result).toBe("John Doe");
+		});
+
+		it("should handle nested data access via lodash.get", () => {
+			const ctx = createMockContext();
+			const data = { user: { name: "Alice" } };
+			const result = mapper.replaceString("Hi ${user.name}", ctx, data);
+			expect(result).toBe("Hi Alice");
+		});
+
+		it("should handle no matches (no ${})", () => {
+			const ctx = createMockContext();
+			const result = mapper.replaceString("plain text", ctx, {});
+			expect(result).toBe("plain text");
+		});
+
+		it("should execute js/ prefix expressions", () => {
+			const ctx = createMockContext();
+			const result = mapper.replaceString("js/1 + 2", ctx, {});
+			expect(result).toBe(3);
+		});
+
+		it("should pass through non-js strings", () => {
+			const ctx = createMockContext();
+			const result = mapper.replaceString("hello world", ctx, {});
+			expect(result).toBe("hello world");
+		});
+
+		it("should handle errors silently in placeholder replacement", () => {
+			const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+			const ctx = createMockContext();
+			// An expression that throws inside Function()
+			const result = mapper.replaceString("${undefinedVar.deep.access}", ctx, {});
+			// Should not throw, returns string with attempted replacement
+			expect(result).toBeTypeOf("string");
+			consoleSpy.mockRestore();
+		});
+	});
+
+	describe("replaceObjectStrings()", () => {
+		it("should replace string values in flat object", () => {
+			const ctx = createMockContext();
+			const data = { greeting: "World" };
+			const obj: Record<string, unknown> = { msg: "Hello ${greeting}" };
+			mapper.replaceObjectStrings(obj, ctx, data);
+			expect(obj.msg).toBe("Hello World");
+		});
+
+		it("should recursively replace nested objects", () => {
+			const ctx = createMockContext();
+			const data = { val: "replaced" };
+			const obj: Record<string, unknown> = {
+				level1: {
+					level2: "value is ${val}",
+				},
+			};
+			mapper.replaceObjectStrings(obj, ctx, data);
+			expect((obj.level1 as Record<string, unknown>).level2).toBe("value is replaced");
+		});
+
+		it("should skip non-string, non-object values", () => {
+			const ctx = createMockContext();
+			const obj: Record<string, unknown> = { num: 42, bool: true, str: "keep" };
+			mapper.replaceObjectStrings(obj, ctx, {});
+			expect(obj.num).toBe(42);
+			expect(obj.bool).toBe(true);
+			expect(obj.str).toBe("keep");
+		});
+	});
+
+	describe("jsMapper via replaceString", () => {
+		it("should access ctx in js/ expressions", () => {
+			const ctx = createMockContext({ vars: { count: 5 } });
+			const result = mapper.replaceString("js/ctx.vars.count", ctx, {});
+			expect(result).toBe(5);
+		});
+
+		it("should handle js/ errors silently", () => {
+			const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+			const ctx = createMockContext();
+			const result = mapper.replaceString('js/throw new Error("fail")', ctx, {});
+			// Should return the original string on error
+			expect(result).toBe('js/throw new Error("fail")');
+			consoleSpy.mockRestore();
+		});
+	});
+});

package/__tests__/unit/utils/MemoryUsage.test.ts

@@ -0,0 +1,121 @@
+import os from "node:os";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import MemoryUsage from "../../../src/utils/MemoryUsage";
+
+describe("MemoryUsage", () => {
+	let memory: MemoryUsage;
+
+	beforeEach(() => {
+		memory = new MemoryUsage();
+		vi.restoreAllMocks();
+	});
+
+	describe("start()", () => {
+		it("should increment counter", () => {
+			vi.spyOn(process, "memoryUsage").mockReturnValue({
+				heapUsed: 50_000_000,
+				heapTotal: 100_000_000,
+				rss: 200_000_000,
+				external: 10_000_000,
+				arrayBuffers: 5_000_000,
+			});
+
+			memory.start();
+			memory.start();
+
+			const metrics = memory.getMetrics();
+			// total is average = total_val / counter, with 2 starts
+			expect(metrics.total).toBeTypeOf("number");
+		});
+
+		it("should track min value", () => {
+			vi.spyOn(process, "memoryUsage")
+				.mockReturnValueOnce({ heapUsed: 100_000_000, heapTotal: 0, rss: 0, external: 0, arrayBuffers: 0 })
+				.mockReturnValueOnce({ heapUsed: 50_000_000, heapTotal: 0, rss: 0, external: 0, arrayBuffers: 0 });
+
+			memory.start();
+			memory.start();
+
+			const metrics = memory.getMetrics();
+			expect(metrics.min).toBe(50); // 50_000_000 / 1_000_000
+		});
+
+		it("should track max value", () => {
+			vi.spyOn(process, "memoryUsage")
+				.mockReturnValueOnce({ heapUsed: 50_000_000, heapTotal: 0, rss: 0, external: 0, arrayBuffers: 0 })
+				.mockReturnValueOnce({ heapUsed: 100_000_000, heapTotal: 0, rss: 0, external: 0, arrayBuffers: 0 });
+
+			memory.start();
+			memory.start();
+
+			const metrics = memory.getMetrics();
+			expect(metrics.max).toBe(100); // 100_000_000 / 1_000_000
+		});
+
+		it("should set min_val on first call", () => {
+			vi.spyOn(process, "memoryUsage").mockReturnValue({
+				heapUsed: 75_000_000,
+				heapTotal: 0,
+				rss: 0,
+				external: 0,
+				arrayBuffers: 0,
+			});
+
+			memory.start();
+
+			const metrics = memory.getMetrics();
+			expect(metrics.min).toBe(75);
+		});
+	});
+
+	describe("stop()", () => {
+		it("should be a no-op", () => {
+			memory.stop();
+			// Should not throw or change state
+			const metrics = memory.getMetrics();
+			expect(metrics.total).toBeNaN(); // 0 / 0
+		});
+	});
+
+	describe("getMetrics()", () => {
+		it("should return average, min, max, global_memory, global_free_memory", () => {
+			vi.spyOn(process, "memoryUsage").mockReturnValue({
+				heapUsed: 50_000_000,
+				heapTotal: 0,
+				rss: 0,
+				external: 0,
+				arrayBuffers: 0,
+			});
+			vi.spyOn(os, "totalmem").mockReturnValue(16_000_000_000);
+			vi.spyOn(os, "freemem").mockReturnValue(8_000_000_000);
+
+			memory.start();
+
+			const metrics = memory.getMetrics();
+			expect(metrics).toHaveProperty("total");
+			expect(metrics).toHaveProperty("min");
+			expect(metrics).toHaveProperty("max");
+			expect(metrics.global_memory).toBe(16000);
+			expect(metrics.global_free_memory).toBe(8000);
+		});
+	});
+
+	describe("clear()", () => {
+		it("should reset all values to 0", () => {
+			vi.spyOn(process, "memoryUsage").mockReturnValue({
+				heapUsed: 50_000_000,
+				heapTotal: 0,
+				rss: 0,
+				external: 0,
+				arrayBuffers: 0,
+			});
+
+			memory.start();
+			memory.clear();
+
+			const metrics = memory.getMetrics();
+			expect(metrics.min).toBe(0);
+			expect(metrics.max).toBe(0);
+		});
+	});
+});

package/__tests__/unit/utils/Time.test.ts

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import Time from "../../../src/utils/Time";
+
+describe("Time", () => {
+	let time: Time;
+
+	beforeEach(() => {
+		time = new Time();
+	});
+
+	describe("start()", () => {
+		it("should record start time as dayjs format", () => {
+			time.start();
+			const metrics = time.getMetrics();
+			expect(metrics.startTime).toBeTypeOf("string");
+			expect(metrics.startTime).not.toBeNull();
+		});
+	});
+
+	describe("stop()", () => {
+		it("should record end time as dayjs format", () => {
+			time.start();
+			time.stop();
+			const metrics = time.getMetrics();
+			expect(metrics.endTime).toBeTypeOf("string");
+			expect(metrics.endTime).not.toBeNull();
+		});
+	});
+
+	describe("getMetrics()", () => {
+		it("should return startTime, endTime, duration", () => {
+			time.start();
+			time.stop();
+
+			const metrics = time.getMetrics();
+			expect(metrics).toHaveProperty("startTime");
+			expect(metrics).toHaveProperty("endTime");
+			expect(metrics).toHaveProperty("duration");
+		});
+
+		it("should have positive duration after start/stop", () => {
+			time.start();
+			// Small delay to ensure measurable duration
+			for (let i = 0; i < 1000; i++) {
+				/* spin */
+			}
+			time.stop();
+
+			const metrics = time.getMetrics();
+			expect(metrics.duration).toBeGreaterThanOrEqual(0);
+		});
+
+		it("should return null times before start", () => {
+			const metrics = time.getMetrics();
+			expect(metrics.startTime).toBeNull();
+			expect(metrics.endTime).toBeNull();
+			expect(metrics.duration).toBe(0);
+		});
+	});
+});

package/dist/GlobalError.d.ts

@@ -0,0 +1,11 @@
+import type ErrorContext from "./types/ErrorContext";
+export default class GlobalError extends Error {
+    context: ErrorContext;
+    constructor(msg: string | undefined);
+    setCode(code?: number): void;
+    setJson(json?: Record<string, unknown>): void;
+    setStack(stack?: string): void;
+    setName(name?: string): void;
+    hasJson(): boolean;
+    toString(): string;
+}

package/dist/GlobalError.js

@@ -0,0 +1,29 @@
+export default class GlobalError extends Error {
+    context = { message: "" };
+    constructor(msg) {
+        super(msg);
+        Object.setPrototypeOf(this, GlobalError.prototype);
+        this.context.message = msg;
+    }
+    setCode(code) {
+        this.context.code = code;
+    }
+    setJson(json) {
+        this.context.json = json;
+    }
+    setStack(stack) {
+        this.context.stack = stack;
+    }
+    setName(name) {
+        this.context.name = name;
+    }
+    hasJson() {
+        return this.context.json !== undefined;
+    }
+    toString() {
+        if (this.context.json)
+            return JSON.stringify(this.context.json);
+        return this.context.message;
+    }
+}
+//# sourceMappingURL=GlobalError.js.map

package/dist/GlobalError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalError.js","sourceRoot":"","sources":["../src/GlobalError.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,KAAK;IACtC,OAAO,GAAiB,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IAE/C,YAAY,GAAuB;QAClC,KAAK,CAAC,GAAG,CAAC,CAAC;QACX,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;QAEnD,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,GAAa,CAAC;IACtC,CAAC;IAED,OAAO,CAAC,IAAa;QACpB,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAC1B,CAAC;IACD,OAAO,CAAC,IAA8B;QACrC,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,IAAwB,CAAC;IAC9C,CAAC;IACD,QAAQ,CAAC,KAAc;QACtB,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;IAC5B,CAAC;IACD,OAAO,CAAC,IAAa;QACpB,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAC1B,CAAC;IAED,OAAO;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,SAAS,CAAC;IACxC,CAAC;IAEQ,QAAQ;QAChB,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAChE,OAAO,IAAI,CAAC,OAAO,CAAC,OAAiB,CAAC;IACvC,CAAC;CACD"}

package/dist/GlobalLogger.d.ts

@@ -0,0 +1,11 @@
+import type LoggerContext from "./types/LoggerContext";
+export default abstract class GlobalLogger implements LoggerContext {
+    protected logs: string[];
+    constructor();
+    abstract log(message: string): void;
+    abstract logLevel(level: string, message: string): void;
+    abstract error(message: string, stack: string): void;
+    getLogs(): string[];
+    getLogsAsText(): string;
+    getLogsAsBase64(): string;
+}

package/dist/GlobalLogger.js

@@ -0,0 +1,16 @@
+export default class GlobalLogger {
+    logs;
+    constructor() {
+        this.logs = [];
+    }
+    getLogs() {
+        return this.logs;
+    }
+    getLogsAsText() {
+        return this.logs.join("\n");
+    }
+    getLogsAsBase64() {
+        return Buffer.from(this.logs.join("\n")).toString("base64");
+    }
+}
+//# sourceMappingURL=GlobalLogger.js.map

package/dist/GlobalLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalLogger.js","sourceRoot":"","sources":["../src/GlobalLogger.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAgB,YAAY;IAC/B,IAAI,CAAW;IAEzB;QACC,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;IAChB,CAAC;IAMD,OAAO;QACN,OAAO,IAAI,CAAC,IAAI,CAAC;IAClB,CAAC;IAED,aAAa;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAED,eAAe;QACd,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC7D,CAAC;CACD"}

package/dist/Metrics.d.ts

@@ -0,0 +1,18 @@
+import type { CpuUsageType, MemoryUsageType, TimeUsageType } from "./utils/MetricsBase";
+declare class Metrics {
+    private cpuUsage;
+    private memoryUsage;
+    private time;
+    constructor();
+    start(): void;
+    retry(): void;
+    stop(): void;
+    clear(): void;
+    getMetrics(): MetricsType;
+}
+type MetricsType = {
+    cpu: CpuUsageType;
+    memory: MemoryUsageType;
+    time: TimeUsageType;
+};
+export { Metrics, type MetricsType };

package/dist/Metrics.js

@@ -0,0 +1,40 @@
+import { CpuUsage, Time } from "./utils";
+import MemoryUsage from "./utils/MemoryUsage";
+class Metrics {
+    cpuUsage;
+    memoryUsage;
+    time;
+    constructor() {
+        this.cpuUsage = new CpuUsage();
+        this.memoryUsage = new MemoryUsage();
+        this.time = new Time();
+    }
+    start() {
+        this.cpuUsage.start();
+        this.memoryUsage.start();
+        this.time.start();
+    }
+    retry() {
+        this.memoryUsage.start();
+    }
+    stop() {
+        this.cpuUsage.stop();
+        this.time.stop();
+        this.memoryUsage.stop();
+    }
+    clear() {
+        this.memoryUsage.clear();
+    }
+    getMetrics() {
+        const cpu = this.cpuUsage.getMetrics();
+        const memory = this.memoryUsage.getMetrics();
+        const time = this.time.getMetrics();
+        return {
+            cpu,
+            memory: memory,
+            time,
+        };
+    }
+}
+export { Metrics };
+//# sourceMappingURL=Metrics.js.map

package/dist/Metrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Metrics.js","sourceRoot":"","sources":["../src/Metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,WAAW,MAAM,qBAAqB,CAAC;AAG9C,MAAM,OAAO;IACJ,QAAQ,CAAW;IACnB,WAAW,CAAc;IACzB,IAAI,CAAO;IAEnB;QACC,IAAI,CAAC,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,EAAE,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IACxB,CAAC;IAEM,KAAK;QACX,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC;IAEM,KAAK;QACX,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;IAC1B,CAAC;IAEM,IAAI;QACV,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACjB,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;IACzB,CAAC;IAEM,KAAK;QACX,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;IAC1B,CAAC;IAEM,UAAU;QAChB,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;QACvC,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;QAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QAEpC,OAAO;YACN,GAAG;YACH,MAAM,EAAE,MAAM;YACd,IAAI;SACJ,CAAC;IACH,CAAC;CACD;AAQD,OAAO,EAAE,OAAO,EAAoB,CAAC"}

package/dist/NodeBase.d.ts

@@ -0,0 +1,26 @@
+import GlobalError from "./GlobalError";
+import type Context from "./types/Context";
+import type ErrorContext from "./types/ErrorContext";
+import type FunctionContext from "./types/FunctionContext";
+import type ParamsDictionary from "./types/ParamsDictionary";
+import type ResponseContext from "./types/ResponseContext";
+import type Step from "./types/Step";
+import type VarsContext from "./types/VarsContext";
+export default abstract class NodeBase {
+    flow: boolean;
+    name: string;
+    contentType: string;
+    active: boolean;
+    stop: boolean;
+    originalConfig: ParamsDictionary;
+    set_var: boolean;
+    process(ctx: Context, step?: Step): Promise<ResponseContext>;
+    processFlow(ctx: Context): Promise<ResponseContext>;
+    abstract run(ctx: Context): Promise<ResponseContext>;
+    runSteps(step: Step | Step[], ctx: Context): Promise<Context>;
+    runJs(str: string, ctx: Context, data?: ParamsDictionary, func?: FunctionContext, vars?: VarsContext): ParamsDictionary;
+    setVar(ctx: Context, vars: VarsContext): void;
+    getVar(ctx: Context, name: string): ParamsDictionary | undefined;
+    blueprintMapper: (obj: ParamsDictionary, ctx: Context, data?: ParamsDictionary) => string | ParamsDictionary;
+    setError(config: ErrorContext): GlobalError;
+}

package/dist/NodeBase.js

@@ -0,0 +1,98 @@
+import _ from "lodash";
+import GlobalError from "./GlobalError";
+import mapper from "./utils/Mapper";
+export default class NodeBase {
+    flow = false;
+    name = "";
+    contentType = "";
+    active = true;
+    stop = false;
+    originalConfig = {};
+    set_var = false;
+    async process(ctx, step) {
+        let response = {
+            success: true,
+            data: null,
+            error: null,
+        };
+        const config = ctx.config;
+        this.originalConfig = _.cloneDeep(config[this.name]);
+        this.blueprintMapper(config[this.name], ctx);
+        response = await this.run(ctx);
+        if (response.error)
+            throw response.error;
+        ctx.response = response;
+        return response;
+    }
+    async processFlow(ctx) {
+        let response = {
+            success: true,
+            data: null,
+            error: null,
+        };
+        try {
+            const config = ctx.config;
+            this.blueprintMapper(config[this.name], ctx);
+            response = await this.run(ctx);
+        }
+        catch (error) {
+            response.error = this.setError(error);
+            response.success = false;
+            ctx.response = response;
+        }
+        return response;
+    }
+    runSteps(step, ctx) {
+        console.error("[Error] runSteps method is not implemented.");
+        throw new Error("runSteps method is not implemented.");
+    }
+    runJs(str, ctx, data = {}, func = {}, vars = {}) {
+        return Function("ctx", "data", "func", "vars", `"use strict";return (${str});`)(ctx, data, func, vars);
+    }
+    setVar(ctx, vars) {
+        if (ctx.vars === undefined)
+            ctx.vars = {};
+        ctx.vars = { ...ctx.vars, ...vars };
+    }
+    getVar(ctx, name) {
+        return ctx.vars?.[name];
+    }
+    blueprintMapper = (obj, ctx, data) => {
+        let newObj = obj;
+        try {
+            if (typeof obj === "string")
+                newObj = mapper.replaceString(obj, ctx, data);
+            else
+                mapper.replaceObjectStrings(newObj, ctx, data);
+        }
+        catch (e) {
+            console.log("MAPPER ERROR", e);
+        }
+        return newObj;
+    };
+    setError(config) {
+        let errorHandler;
+        if (typeof config === "string") {
+            errorHandler = new GlobalError(config);
+        }
+        else if (config.message && Object.keys(config).length === 1) {
+            errorHandler = new GlobalError(config.message);
+        }
+        else {
+            const err = typeof config === "object" ? JSON.stringify(config) : "Unkwon Error";
+            errorHandler = new GlobalError(err);
+            if (typeof config === "object") {
+                errorHandler.setJson(config);
+            }
+        }
+        if (config.json)
+            errorHandler.setJson(config);
+        if (config.stack)
+            errorHandler.setStack(config.stack);
+        if (config.code)
+            errorHandler.setCode(typeof config.code === "number" ? config.code : 500);
+        errorHandler.setName(this.name);
+        return errorHandler;
+    }
+}
+//# sourceMappingURL=NodeBase.js.map