blokctl 1.3.0 → 1.4.0

package/dist/scaffold-repo/triggers/grpc/src/GrpcClient.ts

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

package/dist/scaffold-repo/triggers/grpc/src/GrpcServer.ts

@@ -0,0 +1,68 @@
+import { DefaultLogger } from "@blokjs/runner";
+import type { ConnectRouter } from "@connectrpc/connect";
+import { fastifyConnectPlugin } from "@connectrpc/connect-fastify";
+import { type Span, metrics, trace } from "@opentelemetry/api";
+import GRpcTrigger from "./GRpcTrigger";
+
+export type GrpcServerOptions = {
+	host: string;
+	port: number;
+	// Optional node/workflow maps to run instead of the package's built-ins —
+	// a scaffolded project passes its own src/Nodes.ts + src/Workflows.ts so
+	// `blokctl dev` serves the user's nodes/workflows over gRPC.
+	nodes?: Record<string, unknown>;
+	workflows?: Record<string, unknown>;
+};
+
+export default class GrpcServer {
+	protected opts: GrpcServerOptions;
+	protected tracer = trace.getTracer(
+		process.env.PROJECT_NAME || "trigger-grpc-server",
+		process.env.PROJECT_VERSION || "0.0.1",
+	);
+	protected app_cold_start = metrics.getMeter("default").createGauge("initialization", {
+		description: "Application cold start",
+	});
+	protected initializer = 0;
+	protected logger = new DefaultLogger();
+
+	constructor(opts: GrpcServerOptions) {
+		this.opts = opts;
+
+		if (this.opts.host === undefined) {
+			this.opts.host = "0.0.0.0";
+		}
+
+		if (this.opts.port === undefined) {
+			this.opts.port = 8443;
+		}
+
+		this.initializer = performance.now();
+	}
+
+	async start() {
+		this.tracer.startActiveSpan("initialization", async (span: Span) => {
+			const trigger = new GRpcTrigger({ nodes: this.opts.nodes, workflows: this.opts.workflows });
+			const server = trigger.getApp();
+			const host = process.env.GRPC_HOST || this.opts.host;
+			let port: string | number = process.env.GRPC_PORT || this.opts.port;
+			if (typeof port === "string") {
+				port = Number.parseInt(port, 10);
+			}
+			await server.register(fastifyConnectPlugin, {
+				routes: (router: ConnectRouter) => trigger.processRequest(router, trigger),
+			});
+			await server.listen({ host, port: port });
+			this.logger.log(`Server is listening at ${JSON.stringify(server.addresses())}`);
+
+			this.initializer = performance.now() - this.initializer;
+			this.logger.log(`Server initialized in ${(this.initializer).toFixed(2)}ms`);
+			this.app_cold_start.record(this.initializer, {
+				pid: process.pid,
+				env: process.env.NODE_ENV,
+				app: process.env.APP_NAME,
+			});
+			span.end();
+		});
+	}
+}

package/dist/scaffold-repo/triggers/grpc/src/MessageDecode.ts

@@ -0,0 +1,142 @@
+import type { JsonLikeObject } from "@blokjs/runner";
+import type { Context } from "@blokjs/shared";
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+import { MessageEncoding, MessageType, type WorkflowRequest, type WorkflowResponse } from "./gen/workflow_pb";
+
+export default class MessageDecode {
+	requestDecode(request: WorkflowRequest): Context {
+		let message: Context = <Context>{};
+
+		switch (request.Encoding) {
+			case MessageEncoding[MessageEncoding.BASE64]: {
+				const messageStr = Buffer.from(request.Message, "base64").toString("utf-8");
+				message = this.decodeType(messageStr, request.Type);
+				break;
+			}
+			case MessageEncoding[MessageEncoding.STRING]: {
+				message = this.decodeType(request.Message, request.Type);
+				break;
+			}
+			default:
+				throw new Error(`Unsupported encoding: ${request.Encoding}`);
+		}
+
+		return message;
+	}
+
+	decodeType(message: string, type: string): Context {
+		switch (type) {
+			case MessageType[MessageType.JSON]: {
+				return JSON.parse(message);
+			}
+			case MessageType[MessageType.XML]: {
+				return new XMLParser().parse(message);
+			}
+			default:
+				throw new Error(`Unsupported type: ${type}`);
+		}
+	}
+
+	responseEncode(ctx: Context, encoding: string, type: string): WorkflowResponse {
+		let message: string | object | Buffer<ArrayBuffer>;
+		const responseType = this.mapContentType(ctx.response.contentType as string);
+		switch (encoding) {
+			case MessageEncoding[MessageEncoding.BASE64]: {
+				if (responseType === MessageType.JSON) {
+					message = this.encodeType(ctx.response.data as JsonLikeObject, type);
+					message = Buffer.from(message).toString("base64");
+				}
+				if (responseType === MessageType.XML) {
+					message = this.encodeType(ctx.response.data as object, type);
+					message = Buffer.from(message).toString("base64");
+				} else {
+					message = this.encodeType(ctx.response.data as string, type);
+					message = Buffer.from(message).toString("base64");
+				}
+				break;
+			}
+			case MessageEncoding[MessageEncoding.STRING]: {
+				if (responseType === MessageType.JSON) {
+					message = this.encodeType(ctx.response.data as JsonLikeObject, type);
+				}
+				if (responseType === MessageType.XML) {
+					message = this.encodeType(ctx.response.data as object, type);
+				} else {
+					message = this.encodeType(ctx.response.data as string, type);
+				}
+				break;
+			}
+			default:
+				throw new Error(`Unsupported encoding: ${encoding}`);
+		}
+
+		return {
+			Message: message,
+			Encoding: encoding,
+			Type: MessageType[responseType],
+		} as WorkflowResponse;
+	}
+
+	responseErrorEncode(e: string | JsonLikeObject, encoding: string, type: string): string {
+		let message: string | object | Buffer<ArrayBuffer>;
+		switch (encoding) {
+			case MessageEncoding[MessageEncoding.BASE64]:
+				message = Buffer.from(this.encodeType(e, type)).toString("base64");
+				break;
+			case MessageEncoding[MessageEncoding.STRING]:
+				message = this.encodeType(e, type);
+				break;
+			default:
+				throw new Error(`Unsupported encoding: ${encoding}`);
+		}
+
+		return message as string;
+	}
+
+	responseDecode(response: WorkflowResponse): JsonLikeObject {
+		let message: JsonLikeObject = {};
+
+		switch (response.Encoding) {
+			case MessageEncoding[MessageEncoding.BASE64]: {
+				const messageStr = Buffer.from(response.Message, "base64").toString("utf-8");
+				message = this.decodeType(messageStr, response.Type) as unknown as JsonLikeObject;
+				break;
+			}
+			case MessageEncoding[MessageEncoding.STRING]: {
+				message = this.decodeType(response.Message, response.Type) as unknown as JsonLikeObject;
+				break;
+			}
+			default:
+				throw new Error(`Unsupported encoding: ${response.Encoding}`);
+		}
+
+		return message;
+	}
+
+	encodeType(message: string | object | Buffer<ArrayBuffer>, type: string): string {
+		switch (type) {
+			case MessageType[MessageType.JSON]:
+				return JSON.stringify(message);
+			case MessageType[MessageType.TEXT]:
+			case MessageType[MessageType.HTML]:
+				return message.toString();
+			case MessageType[MessageType.XML]:
+				return new XMLBuilder().build(message);
+			default:
+				throw new Error(`Unsupported type: ${type}`);
+		}
+	}
+
+	mapContentType(contentType: string): MessageType {
+		switch (contentType) {
+			case "application/json":
+				return MessageType.JSON;
+			case "text/html":
+				return MessageType.HTML;
+			case "text/xml":
+				return MessageType.XML;
+			default:
+				return MessageType.TEXT;
+		}
+	}
+}

package/dist/scaffold-repo/triggers/grpc/src/NanoSDK.ts

@@ -0,0 +1,146 @@
+import fs from "node:fs";
+import type { JsonLikeObject } from "@blokjs/runner";
+import GrpcClient, { type RpcOptions, type WorkflowRequest, HttpVersionEnum, TransportEnum } from "./GrpcClient";
+import MessageDecode from "./MessageDecode";
+
+export default class NanoSDK {
+	public createClient(host?: string, token?: string) {
+		let _host = host || "localhost:8433";
+		let _token = token || "";
+
+		if (!host) {
+			const app_path = process.cwd();
+			// Validate if the file nanosdk.json exists
+			if (fs.existsSync(`${app_path}/nanosdk.json`)) {
+				const data = fs.readFileSync(`${app_path}/nanosdk.json`, "utf8");
+				const json = JSON.parse(data);
+				_host = json.host;
+				_token = json.token;
+			}
+		}
+
+		// Validate if the host does not have the format domain:port without http:// or https://
+		if (!_host.includes("http://") && !_host.includes("https://")) {
+			if (!_host.includes(":")) {
+				throw new Error("Invalid host format. The host must have the format domain:port");
+			}
+		}
+
+		// get host and port
+		const host_port = _host.split(":");
+
+		return new NanoSDKClient(
+			{
+				host: host_port[0] || "localhost",
+				port: Number.parseInt(host_port[1]),
+				protocol: "http",
+				httpVersion: HttpVersionEnum.HTTP2,
+				transport: TransportEnum.GRPC,
+			},
+			_token,
+		);
+	}
+}
+
+export class NanoSDKClient {
+	private client: GrpcClient;
+	private token: string;
+
+	constructor(options: RpcOptions, token: string) {
+		this.client = new GrpcClient(options);
+		this.token = token;
+	}
+
+	public async python3(nodeName: string, inputs: JsonLikeObject): Promise<JsonLikeObject> {
+		const workflow = {
+			name: "Remote Node",
+			description: "Execution of remote node",
+			version: "1.0.0",
+			trigger: {
+				grpc: {},
+			},
+			steps: [
+				{
+					name: "node",
+					node: nodeName,
+					type: "runtime.python3",
+				},
+			],
+			nodes: {
+				node: {
+					inputs: inputs,
+				},
+			},
+		};
+
+		const base64Workflow = Buffer.from(JSON.stringify({ request: {}, workflow: workflow })).toString("base64");
+		const request: WorkflowRequest = {
+			$typeName: "blok.workflow.v1.WorkflowRequest",
+			Name: nodeName,
+			Message: base64Workflow,
+			Encoding: "BASE64",
+			Type: "JSON",
+		};
+
+		return await this.call(request);
+	}
+
+	public async nodejs(nodeName: string, inputs: JsonLikeObject, type = "module"): Promise<JsonLikeObject> {
+		const workflow = {
+			name: "Remote Node",
+			description: "Execution of remote node",
+			version: "1.0.0",
+			trigger: {
+				http: {
+					method: "GET",
+					path: "/",
+					accept: "application/json",
+				},
+			},
+			steps: [
+				{
+					name: "node",
+					node: nodeName,
+					type: type,
+				},
+			],
+			nodes: {
+				node: {
+					inputs: inputs,
+				},
+			},
+		};
+
+		const base64Workflow = Buffer.from(JSON.stringify({ request: {}, workflow: workflow })).toString("base64");
+		const request: WorkflowRequest = {
+			$typeName: "blok.workflow.v1.WorkflowRequest",
+			Name: nodeName,
+			Message: base64Workflow,
+			Encoding: "BASE64",
+			Type: "JSON",
+		};
+
+		return await this.call(request);
+	}
+
+	protected async call(message: WorkflowRequest): Promise<JsonLikeObject> {
+		const response = await this.client.call(message, { headers: { Authorization: `Bearer ${this.token}` } });
+		const decode = new MessageDecode();
+		const responseDecoded = decode.responseDecode(response);
+		return responseDecoded;
+	}
+}
+
+// const client = new NanoSDK().createClient("127.0.0.1:8433", "");
+// client.python3("api_call", {
+//     "url": "https://countriesnow.space/api/v0.1/countries/capital",
+//     "method": "GET",
+//     "headers": {
+//         "Content-Type": "application/json"
+//     },
+//     "responseType": "application/json"
+// }).then((response) => {
+//     console.log(response);
+// }).catch((error) => {
+//     console.error("ERROR", error);
+// });

package/dist/scaffold-repo/triggers/grpc/src/Nodes.ts

@@ -0,0 +1,10 @@
+import ApiCall from "@blokjs/api-call";
+import IfElse from "@blokjs/if-else";
+import type { BlokService } from "@blokjs/runner";
+
+const nodes: Record<string, BlokService<unknown>> = {
+	"@blokjs/api-call": ApiCall,
+	"@blokjs/if-else": IfElse,
+};
+
+export default nodes;

package/dist/scaffold-repo/triggers/grpc/src/Workflows.ts

@@ -0,0 +1,5 @@
+import type Workflows from "./types/Workflows";
+
+const workflows: Workflows = {};
+
+export default workflows;

package/dist/scaffold-repo/triggers/grpc/src/gen/workflow_pb.ts

@@ -0,0 +1,142 @@
+// @generated by protoc-gen-es v2.2.3 with parameter "target=ts"
+// @generated from file workflow.proto (package blok.workflow.v1, syntax proto3)
+/* eslint-disable */
+
+import type { Message } from "@bufbuild/protobuf";
+import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1";
+import { enumDesc, fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1";
+
+/**
+ * Describes the file workflow.proto.
+ */
+export const file_workflow: GenFile =
+	/*@__PURE__*/
+	fileDesc(
+		"Cg53b3JrZmxvdy5wcm90bxIXbmFub3NlcnZpY2Uud29ya2Zsb3cudjEiUAoPV29ya2Zsb3dSZXF1ZXN0EgwKBE5hbWUYASABKAkSDwoHTWVzc2FnZRgCIAEoCRIQCghFbmNvZGluZxgDIAEoCRIMCgRUeXBlGAQgASgJIkMKEFdvcmtmbG93UmVzcG9uc2USDwoHTWVzc2FnZRgBIAEoCRIQCghFbmNvZGluZxgCIAEoCRIMCgRUeXBlGAMgASgJKikKD01lc3NhZ2VFbmNvZGluZxIKCgZCQVNFNjQQABIKCgZTVFJJTkcQASpACgtNZXNzYWdlVHlwZRIICgRURVhUEAASCAoESlNPThABEgcKA1hNTBACEggKBEhUTUwQAxIKCgZCSU5BUlkQBDJ7Cg9Xb3JrZmxvd1NlcnZpY2USaAoPRXhlY3V0ZVdvcmtmbG93EigubmFub3NlcnZpY2Uud29ya2Zsb3cudjEuV29ya2Zsb3dSZXF1ZXN0GikubmFub3NlcnZpY2Uud29ya2Zsb3cudjEuV29ya2Zsb3dSZXNwb25zZSIAYgZwcm90bzM",
+	);
+
+/**
+ * @generated from message blok.workflow.v1.WorkflowRequest
+ */
+export type WorkflowRequest = Message<"blok.workflow.v1.WorkflowRequest"> & {
+	/**
+	 * @generated from field: string Name = 1;
+	 */
+	Name: string;
+
+	/**
+	 * @generated from field: string Message = 2;
+	 */
+	Message: string;
+
+	/**
+	 * @generated from field: string Encoding = 3;
+	 */
+	Encoding: string;
+
+	/**
+	 * @generated from field: string Type = 4;
+	 */
+	Type: string;
+};
+
+/**
+ * Describes the message blok.workflow.v1.WorkflowRequest.
+ * Use `create(WorkflowRequestSchema)` to create a new message.
+ */
+export const WorkflowRequestSchema: GenMessage<WorkflowRequest> = /*@__PURE__*/ messageDesc(file_workflow, 0);
+
+/**
+ * @generated from message blok.workflow.v1.WorkflowResponse
+ */
+export type WorkflowResponse = Message<"blok.workflow.v1.WorkflowResponse"> & {
+	/**
+	 * @generated from field: string Message = 1;
+	 */
+	Message: string;
+
+	/**
+	 * @generated from field: string Encoding = 2;
+	 */
+	Encoding: string;
+
+	/**
+	 * @generated from field: string Type = 3;
+	 */
+	Type: string;
+};
+
+/**
+ * Describes the message blok.workflow.v1.WorkflowResponse.
+ * Use `create(WorkflowResponseSchema)` to create a new message.
+ */
+export const WorkflowResponseSchema: GenMessage<WorkflowResponse> = /*@__PURE__*/ messageDesc(file_workflow, 1);
+
+/**
+ * @generated from enum blok.workflow.v1.MessageEncoding
+ */
+export enum MessageEncoding {
+	/**
+	 * @generated from enum value: BASE64 = 0;
+	 */
+	BASE64 = 0,
+
+	/**
+	 * @generated from enum value: STRING = 1;
+	 */
+	STRING = 1,
+}
+
+/**
+ * Describes the enum blok.workflow.v1.MessageEncoding.
+ */
+export const MessageEncodingSchema: GenEnum<MessageEncoding> = /*@__PURE__*/ enumDesc(file_workflow, 0);
+
+/**
+ * @generated from enum blok.workflow.v1.MessageType
+ */
+export enum MessageType {
+	/**
+	 * @generated from enum value: TEXT = 0;
+	 */
+	TEXT = 0,
+
+	/**
+	 * @generated from enum value: JSON = 1;
+	 */
+	JSON = 1,
+
+	/**
+	 * @generated from enum value: XML = 2;
+	 */
+	XML = 2,
+
+	/**
+	 * @generated from enum value: HTML = 3;
+	 */
+	HTML = 3,
+
+	/**
+	 * @generated from enum value: BINARY = 4;
+	 */
+	BINARY = 4,
+}
+
+/**
+ * Describes the enum blok.workflow.v1.MessageType.
+ */
+export const MessageTypeSchema: GenEnum<MessageType> = /*@__PURE__*/ enumDesc(file_workflow, 1);
+
+/**
+ * @generated from service blok.workflow.v1.WorkflowService
+ */
+export const WorkflowService: GenService<{
+	/**
+	 * @generated from rpc blok.workflow.v1.WorkflowService.ExecuteWorkflow
+	 */
+	executeWorkflow: {
+		methodKind: "unary";
+		input: typeof WorkflowRequestSchema;
+		output: typeof WorkflowResponseSchema;
+	};
+}> = /*@__PURE__*/ serviceDesc(file_workflow, 0);

package/dist/scaffold-repo/triggers/grpc/src/index.ts

@@ -0,0 +1,22 @@
+import GrpcClient from "./GrpcClient";
+import { RpcOptions } from "./GrpcClient";
+import { CallOptions } from "./GrpcClient";
+import { TransportEnum } from "./GrpcClient";
+import { HttpVersionEnum } from "./GrpcClient";
+import GrpcServer from "./GrpcServer";
+import { GrpcServerOptions } from "./GrpcServer";
+import NanoSDK from "./NanoSDK";
+import { WorkflowRequest, WorkflowResponse } from "./gen/workflow_pb";
+
+export {
+	GrpcClient,
+	RpcOptions,
+	CallOptions,
+	TransportEnum,
+	HttpVersionEnum,
+	WorkflowRequest,
+	WorkflowResponse,
+	GrpcServer,
+	GrpcServerOptions,
+	NanoSDK,
+};

package/dist/scaffold-repo/triggers/grpc/src/server.ts

@@ -0,0 +1,8 @@
+import GrpcServer from "./GrpcServer";
+
+const server = new GrpcServer({
+	host: "0.0.0.0",
+	port: 8443,
+});
+
+server.start();

package/dist/scaffold-repo/triggers/grpc/src/types/RuntimeWorkflow.ts

@@ -0,0 +1,7 @@
+import type { ParamsDictionary } from "@blokjs/runner";
+
+type RuntimeWorkflow = {
+	workflow: ParamsDictionary;
+};
+
+export default RuntimeWorkflow;

package/dist/scaffold-repo/triggers/grpc/src/types/Workflows.ts

@@ -0,0 +1,7 @@
+import type { WorkflowV2Builder } from "@blokjs/helper";
+
+type Workflows = {
+	[key: string]: WorkflowV2Builder;
+};
+
+export default Workflows;

package/dist/scaffold-repo/triggers/grpc/tsconfig.json

@@ -0,0 +1,34 @@
+{
+	"ts-node": {
+		"transpileOnly": true
+	},
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "es2022",
+		"moduleResolution": "bundler",
+		"rootDir": "./src",
+		"baseUrl": ".",
+		"paths": {
+			"@nodes/*": ["./src/nodes/*"],
+			"@src/*": ["src/*"]
+		},
+		"allowJs": true,
+		"declaration": true,
+		"sourceMap": true,
+		"outDir": "./dist",
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"strict": true,
+		"noUnusedLocals": true,
+		"noImplicitReturns": true,
+		"skipLibCheck": true
+	},
+	"compileOnSave": true,
+	"include": [
+		"./src",
+		"./src/nodes/**/*.json",
+		"./src/nodes/**/*.md",
+		"./src/*.json"
+	],
+	"exclude": ["src/nodes/**/test/*.ts", "node_modules"]
+}