@codenotch/codenotch.cli 1.0.33 → 1.0.34

package/src/utils/OpenAPIUtils.ts

@@ -1,285 +0,0 @@
-import OpenAPISpec, { APIController, APIParameter, APIResponse, SchemaType } from "../models/OpenApiModels";
-import ProjectCompilationUtils, { CompilationContext } from "./ProjectCompilationUtils";
-import { IVariable, VariableType } from "@codenotch/codenotch.core";
-import { IFlow, IProcess, IWorkflowApiEventDefinition, IWorkflowBoundary, IWorkflowCallbackEventDefinition, IWorkflowEvent, IWorkflowItem, IWorkflowItemWithPosition, IWorkflowTask, WorkflowItemType } from "@codenotch/codenotch.core.workflow";
-
-export abstract class OpenApiUtils {
-
-    static async generateOpenApi(context: CompilationContext): Promise<OpenAPISpec | undefined> {
-        let openApi = new OpenAPISpec();
-        let apiCount = 0;
-
-        for(let processId in context.processes) {
-            if(!context.processes[processId]) {
-                continue;
-            }
-
-            try {
-                if (this.AddBPMN(openApi, context.processes[processId]!)) {
-                    apiCount++;
-                }
-            }
-            catch (e) {
-                context.errors.push(`Failed to add process ${processId} to OpenAPI spec: ${e instanceof Error ? e.message : String(e)}`);
-            }
-        }
-
-        if (apiCount === 0) {
-            return undefined;
-        }
-
-        return openApi;
-    }
-
-
-    /**
-     * Convert codevariable object to openapi json standard
-     * @param codevariable Code variable object
-     * @returns the converted object
-     */
-    static CodeVariableToOpenAPISchema(codevariable: IVariable): SchemaType {
-        let result = new SchemaType();
-        result.properties = {};
-        result.type = "object";
-
-        codevariable.objectType?.forEach(child => {
-            if (child.type === VariableType.object) {
-                result.properties![child.name] = this.CodeVariableToOpenAPISchema(child);
-            }
-            else if (child.type === VariableType.array) {
-                result.properties![child.name] = new SchemaType();
-                result.properties![child.name].type = ProjectCompilationUtils.ProcessVariableTypeToJsonSchemaTypeName(child.type);
-
-                if (child.arrayType) {
-                    if (child.arrayType.type === VariableType.object)
-                        result.properties![child.name].items = this.CodeVariableToOpenAPISchema(child.arrayType)
-                    else {
-                        result.properties![child.name].items = {
-                            type: ProjectCompilationUtils.ProcessVariableTypeToJsonSchemaTypeName(child.arrayType.type)
-                        }
-                    }
-                }
-            } else {
-                result.properties![child.name] = new SchemaType();
-                result.properties![child.name].type = ProjectCompilationUtils.ProcessVariableTypeToJsonSchemaTypeName(child.type);
-            }
-        });
-
-        return result;
-    }
-
-    /**
-     * Return parameters from codevariables
-     * @param codevariable the codevariable source
-     * @param intype 
-     * @param required 
-     * @returns 
-     */
-    static CodevariableToParameters(codevariable: IVariable, intype: string, required: boolean): APIParameter[] {
-        let result: APIParameter[] = [];
-
-        codevariable?.objectType?.forEach(child => {
-            let parameter = new APIParameter();
-            parameter.name = child.name;
-            parameter.in = intype;
-            parameter.required = required;
-            parameter.schema = new SchemaType();
-            parameter.schema.type = ProjectCompilationUtils.ProcessVariableTypeToJsonSchemaTypeName(child.type);
-            result.push(parameter);
-        });
-
-        return result;
-    }
-
-    /**
-     * Browse the graph recursivly to find api error or api end event
-     * @param item  the start node
-     * @param model the entire bpmn model
-     * @returns the list of node to convert into openapi
-     */
-    static BrowseResponses(item: IWorkflowItem, model: IProcess): IWorkflowItem[] | null {
-
-        let result: IWorkflowItem[];
-
-        if (item.type === WorkflowItemType.ErrorEndEvent
-            || item.type === WorkflowItemType.CallbackEndEvent
-            || item.type === WorkflowItemType.ThrowCallbackIntermediateEvent) {
-            result = [item as IWorkflowEvent];
-
-        } else if ((item as IWorkflowTask)?.errors?.length! > 0) {
-            result = [item as IWorkflowTask];
-        } else {
-            result = [];
-        }
-
-        let flows: IFlow[] = model.items.filter(c => (c as IFlow).sourceId === item.id) as IFlow[];
-
-        flows?.forEach(flow => {
-            let targetNode: IWorkflowItem = model.items.find(c => c.id === flow.targetId) as IWorkflowItem;
-            if (targetNode) {
-                let targetResponses = this.BrowseResponses(targetNode, model);
-                if (targetResponses) {
-                    result = result.concat(targetResponses);
-                }
-            }
-        });
-
-        let boundaries: IWorkflowBoundary[] = model.items.filter(c => (c as IWorkflowBoundary).nodeId === item.id) as IWorkflowBoundary[];
-        boundaries?.forEach(boundary => {
-            let targetResponses = this.BrowseResponses(boundary, model);
-            if (targetResponses) {
-                result = result.concat(targetResponses);
-            }
-        });
-
-        return result;
-    }
-
-    /**
-     * Add bpmn model into open api spec
-     * @param model Bpmn definition model
-     */
-    static AddBPMN(spec: OpenAPISpec, model: IProcess): boolean {
-        //get api start
-        let hasApi = false;
-        let startEvents = model.items.filter(c => c.type === WorkflowItemType.ApiStartEvent);
-        startEvents.forEach(node => {
-            //reterieve eventnode model
-
-                let startEvent = node as IWorkflowEvent;
-
-                let parameters = (startEvent as IWorkflowEvent).outputs[0].outputVariables;
-
-                //get definition
-                let definition: IWorkflowApiEventDefinition = startEvent.eventDefinitions.find(c => c ) as IWorkflowApiEventDefinition;
-                if (definition) {
-                    let apicontroller = new APIController();
-
-                    apicontroller.description = startEvent.desc || "";
-
-                    let body = parameters.find(c => c.name === "body");
-
-                    if (body) {
-                        apicontroller.requestBody = {
-                            "content": {
-                                "application/json": {
-                                    "schema": this.CodeVariableToOpenAPISchema(body as any)
-                                }
-                            }
-                        };
-                    }
-
-                    let header = parameters.find(c => c.name === "header");
-
-                    if (header) {
-                        let parameters = this.CodevariableToParameters(header as any, "header", true);
-                        if (!apicontroller.parameters)
-                            apicontroller.parameters = parameters;
-                        else
-                            apicontroller.parameters = apicontroller.parameters.concat(parameters);
-                    }
-
-                    let query = parameters.find(c => c.name === "query");
-                    if (query) {
-                        let parameters = this.CodevariableToParameters(query as any, "query", true);
-                        if (!apicontroller.parameters)
-                            apicontroller.parameters = parameters;
-                        else
-                            apicontroller.parameters = apicontroller.parameters.concat(parameters);
-                    }
-
-                    let path = parameters.find(c => c.name === "path");
-                    if (path) {
-                        let parameters = this.CodevariableToParameters(path as any, "path", true);
-                        if (!apicontroller.parameters)
-                            apicontroller.parameters = parameters;
-                        else
-                            apicontroller.parameters = apicontroller.parameters.concat(parameters);
-                    }
-
-
-                    let responses = this.BrowseResponses(startEvent, model);
-
-                    responses?.forEach(response => {
-
-                        let eventDefinitions = (node as IWorkflowEvent).eventDefinitions;
-                        let errors = (node as IWorkflowTask).errors;
-                        if (eventDefinitions) {
-                            let callbackeventdefinition: IWorkflowCallbackEventDefinition = eventDefinitions[0] as IWorkflowCallbackEventDefinition;
-
-                            let evtParameters = (response as IWorkflowEvent).outputs[0].outputVariables;
-
-                            if (callbackeventdefinition) {
-                                let apiresponse: APIResponse = new APIResponse();
-                                apiresponse.description = response.desc || "";
-
-                                let responsecode = evtParameters.find(c => c.name === "code");
-                                let code: string = responsecode ? responsecode.value! : "200";
-                                let responseshema = evtParameters.find(c => c.name === "response");
-
-                                let i = (code + "").indexOf('{');
-                                let codeisValid: boolean = i < 0;
-                                if (responseshema && codeisValid) {
-                                    apiresponse.content = {
-                                        "application/json": {
-                                            "schema": this.CodeVariableToOpenAPISchema(responseshema as any)
-                                        }
-                                    }
-                                    apicontroller.responses[code] = apiresponse;
-                                }
-                            }
-                        } else if (errors) {
-                            errors.forEach(error => {
-
-                                if ((error.code + "").indexOf('{') < 0) {
-                                    let apiresponse: APIResponse = new APIResponse();
-                                    apiresponse.description = error.description;
-
-                                    apiresponse.content = {
-                                        "application/json": {
-                                            "schema": {
-                                                "type": "object",
-                                                "properties": {
-                                                    "code": { "type": "string", example: error.code },
-                                                    "message": { "type": "string", example: error.description }
-                                                }
-                                            }
-                                        }
-                                    }
-                                    apicontroller.responses[error.code] = apiresponse;
-                                }
-
-                            })
-                        }
-
-                        //add default error
-                        let apiresponse: APIResponse = new APIResponse();
-                        apiresponse.description = "Server error";
-
-                        apiresponse.content = {
-                            "application/json": {
-                                "schema": {
-                                    "type": "object",
-                                    "properties": {
-                                        "code": { "type": "string", example: "500" },
-                                        "message": { "type": "string", example: "Server error" }
-                                    }
-                                }
-                            }
-                        }
-                        apicontroller.responses["500"] = apiresponse;
-
-                    });
-
-                    if (!spec.paths[definition.route])
-                        spec.paths[definition.route] = {};
-                    spec.paths[definition.route][definition.method] = apicontroller;
-
-                    hasApi = true;
-                }
-            
-        });
-
-        return hasApi;
-    }
-}

package/src/utils/OsUtils.ts

@@ -1,32 +0,0 @@
-import { exec } from 'child_process';
-
-export class OsUtils {
-
-    /**
-     * Opens a URL in the default browser.
-     * Supports Windows, macOS and Linux.
-     * @param url The URL to open.
-     */
-    static openInBrowser(url: string): void {
-        let command: string;
-
-        switch (process.platform) {
-            case 'win32':
-                command = `start "" "${url}"`;
-                break;
-            case 'darwin':
-                command = `open "${url}"`;
-                break;
-            default:
-                // Linux and other Unix-like systems
-                command = `xdg-open "${url}"`;
-                break;
-        }
-
-        exec(command, (error) => {
-            if (error) {
-                console.error(`Failed to open browser: ${error.message}`);
-            }
-        });
-    }
-}