geniebox-shared-lib 2.3.0 → 2.4.1

package/dist/shared.module.d.ts

@@ -44,6 +44,22 @@ export interface SharedModuleOptions {
         protoPath: string;
         url: string;
     };
+    agent?: {
+        protoPath: string;
+        url: string;
+    };
+    mcp?: {
+        protoPath: string;
+        url: string;
+    };
+    workflow?: {
+        protoPath: string;
+        url: string;
+    };
+    library?: {
+        protoPath: string;
+        url: string;
+    };
 }
 export declare class SharedModule {
     private static readonly logger;

package/dist/shared.module.js

@@ -22,6 +22,10 @@ const request_client_1 = require("./request.client");
 const response_client_1 = require("./response.client");
 const billing_client_1 = require("./billing.client");
 const generation_client_1 = require("./generation.client");
+const agent_client_1 = require("./agent.client");
+const mcp_client_1 = require("./mcp.client");
+const library_client_1 = require("./library.client");
+const workflow_client_1 = require("./workflow.client");
 let SharedModule = SharedModule_1 = class SharedModule {
     static forRoot(options = {}) {
         const clients = [];
@@ -326,6 +330,126 @@ let SharedModule = SharedModule_1 = class SharedModule {
         else {
             providers.push({ provide: billing_client_1.BillingClient, useValue: null });
         }
+        // AGENT
+        if (options.agent) {
+            clients.push({
+                name: "AGENT_PACKAGE",
+                transport: microservices_1.Transport.GRPC,
+                options: {
+                    package: "agent",
+                    protoPath: (0, path_1.resolve)(process.cwd(), options.agent.protoPath),
+                    url: options.agent.url,
+                },
+            });
+            providers.push({
+                provide: agent_client_1.AgentClient,
+                useFactory: (client) => {
+                    const svc = new agent_client_1.AgentClient(client);
+                    try {
+                        svc.onModuleInit();
+                        SharedModule_1.logger.log("AgentClient initialized successfully");
+                    }
+                    catch (err) {
+                        SharedModule_1.logger.error("AgentClient initialization failed", err);
+                    }
+                    return svc;
+                },
+                inject: ["AGENT_PACKAGE"],
+            });
+        }
+        else {
+            providers.push({ provide: agent_client_1.AgentClient, useValue: null });
+        }
+        // MCP
+        if (options.mcp) {
+            clients.push({
+                name: "MCP_PACKAGE",
+                transport: microservices_1.Transport.GRPC,
+                options: {
+                    package: "mcp",
+                    protoPath: (0, path_1.resolve)(process.cwd(), options.mcp.protoPath),
+                    url: options.mcp.url,
+                },
+            });
+            providers.push({
+                provide: mcp_client_1.MCPClient,
+                useFactory: (client) => {
+                    const svc = new mcp_client_1.MCPClient(client);
+                    try {
+                        svc.onModuleInit();
+                        SharedModule_1.logger.log("MCPClient initialized successfully");
+                    }
+                    catch (err) {
+                        SharedModule_1.logger.error("MCPClient initialization failed", err);
+                    }
+                    return svc;
+                },
+                inject: ["MCP_PACKAGE"],
+            });
+        }
+        else {
+            providers.push({ provide: mcp_client_1.MCPClient, useValue: null });
+        }
+        // LIBRARY
+        if (options.library) {
+            clients.push({
+                name: "LIBRARY_PACKAGE",
+                transport: microservices_1.Transport.GRPC,
+                options: {
+                    package: "library",
+                    protoPath: (0, path_1.resolve)(process.cwd(), options.library.protoPath),
+                    url: options.library.url,
+                },
+            });
+            providers.push({
+                provide: library_client_1.LibraryClient,
+                useFactory: (client) => {
+                    const svc = new library_client_1.LibraryClient(client);
+                    try {
+                        svc.onModuleInit();
+                        SharedModule_1.logger.log("LibraryClient initialized successfully");
+                    }
+                    catch (err) {
+                        SharedModule_1.logger.error("LibraryClient initialization failed", err);
+                    }
+                    return svc;
+                },
+                inject: ["LIBRARY_PACKAGE"],
+            });
+        }
+        else {
+            providers.push({ provide: library_client_1.LibraryClient, useValue: null });
+        }
+        // WORKFLOW
+        if (options.workflow) {
+            clients.push({
+                name: "WORKFLOW_PACKAGE",
+                transport: microservices_1.Transport.GRPC,
+                options: {
+                    package: "workflow",
+                    protoPath: (0, path_1.resolve)(process.cwd(), options.workflow.protoPath),
+                    url: options.workflow.url,
+                },
+            });
+            providers.push({
+                provide: workflow_client_1.WorkflowClient,
+                useFactory: (client) => {
+                    const svc = new workflow_client_1.WorkflowClient(client);
+                    try {
+                        svc.onModuleInit();
+                        SharedModule_1.logger.log("WorkflowClient initialized successfully");
+                    }
+                    catch (err) {
+                        SharedModule_1.logger.error("WorkflowClient initialization failed", err);
+                    }
+                    return svc;
+                },
+                inject: ["WORKFLOW_PACKAGE"],
+            });
+        }
+        else {
+            providers.push({ provide: workflow_client_1.WorkflowClient, useValue: null });
+        }
         // GENERATION
         if (options.generation) {
             clients.push({

package/dist/workflow.client.d.ts

@@ -0,0 +1,12 @@
+import { OnModuleInit } from "@nestjs/common";
+import { ClientGrpc } from "@nestjs/microservices";
+import { WorkflowServiceClient } from "./workflow.interface";
+export declare class WorkflowClient implements OnModuleInit {
+    private readonly client;
+    private readonly logger;
+    private workflowClient?;
+    constructor(client: ClientGrpc);
+    onModuleInit(): void;
+    get service(): WorkflowServiceClient;
+    isReady(): boolean;
+}

package/dist/workflow.client.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var WorkflowClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowClient = void 0;
+const common_1 = require("@nestjs/common");
+let WorkflowClient = WorkflowClient_1 = class WorkflowClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(WorkflowClient_1.name);
+    }
+    onModuleInit() {
+        this.workflowClient =
+            this.client.getService("WorkflowService");
+        this.logger.log("WorkflowServiceClient initialized");
+    }
+    get service() {
+        if (!this.workflowClient) {
+            throw new common_1.InternalServerErrorException("WorkflowService is not initialized yet");
+        }
+        return this.workflowClient;
+    }
+    isReady() {
+        return !!this.workflowClient;
+    }
+};
+exports.WorkflowClient = WorkflowClient;
+exports.WorkflowClient = WorkflowClient = WorkflowClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("WORKFLOW_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], WorkflowClient);

package/dist/workflow.interface.d.ts

@@ -0,0 +1,289 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Observable } from "rxjs";
+import { Empty } from "./google/protobuf/empty.interface";
+export declare const protobufPackage = "workflow";
+export interface Workflow {
+    id: string;
+    version: string;
+    name: string;
+    icon?: {
+        [key: string]: any;
+    } | undefined;
+    description: string;
+    isPublished: boolean;
+    visibility: string;
+    userId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface WorkflowNode {
+    id: string;
+    version: string;
+    workflowId: string;
+    kind: string;
+    name: string;
+    description: string;
+    uiConfig?: {
+        [key: string]: any;
+    } | undefined;
+    nodeConfig?: {
+        [key: string]: any;
+    } | undefined;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface WorkflowEdge {
+    id: string;
+    version: string;
+    workflowId: string;
+    /** Node ID */
+    source: string;
+    /** Node ID */
+    target: string;
+    uiConfig?: {
+        [key: string]: any;
+    } | undefined;
+    createdAt: string;
+}
+export interface FullWorkflow {
+    workflow?: Workflow | undefined;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+}
+/** Requests */
+export interface CreateWorkflowRequest {
+    userId: string;
+    name: string;
+    description: string;
+    icon?: {
+        [key: string]: any;
+    } | undefined;
+    visibility: string;
+}
+export interface UpdateWorkflowRequest {
+    id: string;
+    userId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    icon?: {
+        [key: string]: any;
+    } | undefined;
+    isPublished?: boolean | undefined;
+    visibility?: string | undefined;
+}
+export interface GetWorkflowRequest {
+    id: string;
+    userId: string;
+}
+export interface ListWorkflowsRequest {
+    userId: string;
+    limit: number;
+    offset: number;
+}
+export interface DeleteWorkflowRequest {
+    id: string;
+    userId: string;
+}
+export interface CreateNodeRequest {
+    workflowId: string;
+    /** Auth */
+    userId: string;
+    kind: string;
+    name: string;
+    description: string;
+    uiConfig?: {
+        [key: string]: any;
+    } | undefined;
+    nodeConfig?: {
+        [key: string]: any;
+    } | undefined;
+}
+export interface UpdateNodeRequest {
+    id: string;
+    userId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    uiConfig?: {
+        [key: string]: any;
+    } | undefined;
+    nodeConfig?: {
+        [key: string]: any;
+    } | undefined;
+}
+export interface DeleteNodeRequest {
+    id: string;
+    userId: string;
+}
+export interface CreateEdgeRequest {
+    workflowId: string;
+    userId: string;
+    source: string;
+    target: string;
+    uiConfig?: {
+        [key: string]: any;
+    } | undefined;
+}
+export interface DeleteEdgeRequest {
+    id: string;
+    userId: string;
+}
+export interface WorkflowsResponse {
+    workflows: Workflow[];
+    total: number;
+}
+export declare const WORKFLOW_PACKAGE_NAME = "workflow";
+export declare const Workflow: MessageFns<Workflow>;
+export declare const WorkflowNode: MessageFns<WorkflowNode>;
+export declare const WorkflowEdge: MessageFns<WorkflowEdge>;
+export declare const FullWorkflow: MessageFns<FullWorkflow>;
+export declare const CreateWorkflowRequest: MessageFns<CreateWorkflowRequest>;
+export declare const UpdateWorkflowRequest: MessageFns<UpdateWorkflowRequest>;
+export declare const GetWorkflowRequest: MessageFns<GetWorkflowRequest>;
+export declare const ListWorkflowsRequest: MessageFns<ListWorkflowsRequest>;
+export declare const DeleteWorkflowRequest: MessageFns<DeleteWorkflowRequest>;
+export declare const CreateNodeRequest: MessageFns<CreateNodeRequest>;
+export declare const UpdateNodeRequest: MessageFns<UpdateNodeRequest>;
+export declare const DeleteNodeRequest: MessageFns<DeleteNodeRequest>;
+export declare const CreateEdgeRequest: MessageFns<CreateEdgeRequest>;
+export declare const DeleteEdgeRequest: MessageFns<DeleteEdgeRequest>;
+export declare const WorkflowsResponse: MessageFns<WorkflowsResponse>;
+export interface WorkflowServiceClient {
+    createWorkflow(request: CreateWorkflowRequest, metadata?: Metadata): Observable<Workflow>;
+    /** Returns graph */
+    getWorkflow(request: GetWorkflowRequest, metadata?: Metadata): Observable<FullWorkflow>;
+    updateWorkflow(request: UpdateWorkflowRequest, metadata?: Metadata): Observable<Workflow>;
+    deleteWorkflow(request: DeleteWorkflowRequest, metadata?: Metadata): Observable<Empty>;
+    listWorkflows(request: ListWorkflowsRequest, metadata?: Metadata): Observable<WorkflowsResponse>;
+    createNode(request: CreateNodeRequest, metadata?: Metadata): Observable<WorkflowNode>;
+    updateNode(request: UpdateNodeRequest, metadata?: Metadata): Observable<WorkflowNode>;
+    deleteNode(request: DeleteNodeRequest, metadata?: Metadata): Observable<Empty>;
+    createEdge(request: CreateEdgeRequest, metadata?: Metadata): Observable<WorkflowEdge>;
+    deleteEdge(request: DeleteEdgeRequest, metadata?: Metadata): Observable<Empty>;
+}
+export interface WorkflowServiceController {
+    createWorkflow(request: CreateWorkflowRequest, metadata?: Metadata): Promise<Workflow> | Observable<Workflow> | Workflow;
+    /** Returns graph */
+    getWorkflow(request: GetWorkflowRequest, metadata?: Metadata): Promise<FullWorkflow> | Observable<FullWorkflow> | FullWorkflow;
+    updateWorkflow(request: UpdateWorkflowRequest, metadata?: Metadata): Promise<Workflow> | Observable<Workflow> | Workflow;
+    deleteWorkflow(request: DeleteWorkflowRequest, metadata?: Metadata): void;
+    listWorkflows(request: ListWorkflowsRequest, metadata?: Metadata): Promise<WorkflowsResponse> | Observable<WorkflowsResponse> | WorkflowsResponse;
+    createNode(request: CreateNodeRequest, metadata?: Metadata): Promise<WorkflowNode> | Observable<WorkflowNode> | WorkflowNode;
+    updateNode(request: UpdateNodeRequest, metadata?: Metadata): Promise<WorkflowNode> | Observable<WorkflowNode> | WorkflowNode;
+    deleteNode(request: DeleteNodeRequest, metadata?: Metadata): void;
+    createEdge(request: CreateEdgeRequest, metadata?: Metadata): Promise<WorkflowEdge> | Observable<WorkflowEdge> | WorkflowEdge;
+    deleteEdge(request: DeleteEdgeRequest, metadata?: Metadata): void;
+}
+export declare function WorkflowServiceControllerMethods(): (constructor: Function) => void;
+export declare const WORKFLOW_SERVICE_NAME = "WorkflowService";
+export type WorkflowServiceService = typeof WorkflowServiceService;
+export declare const WorkflowServiceService: {
+    readonly createWorkflow: {
+        readonly path: "/workflow.WorkflowService/createWorkflow";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateWorkflowRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CreateWorkflowRequest;
+        readonly responseSerialize: (value: Workflow) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Workflow;
+    };
+    /** Returns graph */
+    readonly getWorkflow: {
+        readonly path: "/workflow.WorkflowService/getWorkflow";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetWorkflowRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetWorkflowRequest;
+        readonly responseSerialize: (value: FullWorkflow) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => FullWorkflow;
+    };
+    readonly updateWorkflow: {
+        readonly path: "/workflow.WorkflowService/updateWorkflow";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateWorkflowRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => UpdateWorkflowRequest;
+        readonly responseSerialize: (value: Workflow) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Workflow;
+    };
+    readonly deleteWorkflow: {
+        readonly path: "/workflow.WorkflowService/deleteWorkflow";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteWorkflowRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DeleteWorkflowRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly listWorkflows: {
+        readonly path: "/workflow.WorkflowService/listWorkflows";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListWorkflowsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ListWorkflowsRequest;
+        readonly responseSerialize: (value: WorkflowsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => WorkflowsResponse;
+    };
+    readonly createNode: {
+        readonly path: "/workflow.WorkflowService/createNode";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateNodeRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CreateNodeRequest;
+        readonly responseSerialize: (value: WorkflowNode) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => WorkflowNode;
+    };
+    readonly updateNode: {
+        readonly path: "/workflow.WorkflowService/updateNode";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateNodeRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => UpdateNodeRequest;
+        readonly responseSerialize: (value: WorkflowNode) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => WorkflowNode;
+    };
+    readonly deleteNode: {
+        readonly path: "/workflow.WorkflowService/deleteNode";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteNodeRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DeleteNodeRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly createEdge: {
+        readonly path: "/workflow.WorkflowService/createEdge";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateEdgeRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CreateEdgeRequest;
+        readonly responseSerialize: (value: WorkflowEdge) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => WorkflowEdge;
+    };
+    readonly deleteEdge: {
+        readonly path: "/workflow.WorkflowService/deleteEdge";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteEdgeRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DeleteEdgeRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+};
+export interface WorkflowServiceServer extends UntypedServiceImplementation {
+    createWorkflow: handleUnaryCall<CreateWorkflowRequest, Workflow>;
+    /** Returns graph */
+    getWorkflow: handleUnaryCall<GetWorkflowRequest, FullWorkflow>;
+    updateWorkflow: handleUnaryCall<UpdateWorkflowRequest, Workflow>;
+    deleteWorkflow: handleUnaryCall<DeleteWorkflowRequest, Empty>;
+    listWorkflows: handleUnaryCall<ListWorkflowsRequest, WorkflowsResponse>;
+    createNode: handleUnaryCall<CreateNodeRequest, WorkflowNode>;
+    updateNode: handleUnaryCall<UpdateNodeRequest, WorkflowNode>;
+    deleteNode: handleUnaryCall<DeleteNodeRequest, Empty>;
+    createEdge: handleUnaryCall<CreateEdgeRequest, WorkflowEdge>;
+    deleteEdge: handleUnaryCall<DeleteEdgeRequest, Empty>;
+}
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}