@codenotch/codenotch.cli 1.0.33 → 1.0.34

package/src/utils/ProjectCompilationUtils.ts

@@ -1,1002 +0,0 @@
-import path from "path";
-import { ApplicationManifest, IScenarioProjectManifest, IWorkspaceCache, ProjectManifest, ProjectManifestApi, ProjectManifestApplication, ProjectManifestDatastore, ProjectManifestEmail, ProjectManifestExpressComponent, ProjectManifestHtml, ProjectManifestPdf, ProjectManifestProcess, ProjectManifestProcessStartEvent, ProjectManifestReactApplication, ProjectManigestSignal } from "../models/Codenotch";
-import AbstractRecordContainer, { TableDefinition, FieldType, FieldTypes } from "../models/DbModels";
-import FileUtils from "./FileUtils";
-import I18nUtils from "./I18nUtils";
-import { OpenApiUtils } from "./OpenAPIUtils";
-import ProjectUtils from "./ProjectUtils";
-import StringUtils from "./StringUtils";
-import { JSONSchema7, JSONSchema7TypeName } from "json-schema";
-import { table } from "console";
-import { parse } from "js2xmlparser";
-import BuildUtils from "./BuildUtils";
-import ConsoleUtils from "./ConsoleUtils";
-import { IProcess, IWorkflowPool, BpmnToWorkflowDeserializer, IWorkflowItem, WorkflowItemType, WorkflowPoolType, WorkflowPoolPriority, IWorkflowEvent, IWorkflowSignalEventDefinition, IWorkflowStandardEventDefinition, StaticWorkflowDataProvider } from "@codenotch/codenotch.core.workflow";
-import { IWorkflowDataProvider } from "@codenotch/codenotch.core.workflow/dist/core/IWorkflowDataProvider";
-import { IVariable, VariableType } from "@codenotch/codenotch.core";
-import chalk from "chalk";
-
-// Context used during compilation, can be used to store intermediate data that can be reused during the different compilation steps
-export interface CompilationContext {
-    errors: string[];
-    warnings: string[];
-    targetPath: string; // The path of the compiled project, can be used by different steps to read/write compiled files
-    processes: { [processId: string]: any };
-    documents: { [documentId: string]: AbstractRecordContainer };
-    tables: { [tableId: string]: TableDefinition };
-    manifest?: ProjectManifest;
-    files: string[]; // List of all project files, can be used to avoid reading the file system multiple times
-}
-
-export interface CompilationResult {
-    errors: string[];
-    warnings: string[];
-}
-
-const MANIFEST_FILE_NAME = "manifest.json";
-const DB_SCHEMA_FILE_NAME = "db-schema.xml";
-const MANIFEST_CACHE_FILE_NAME = "manifest.cache.json";
-const OPENAPI_FILE_NAME = "openapi.json";
-
-export default abstract class ProjectCompilationUtils {
-
-    /**
-     * Create a new folder that contains a compiled version of the project
-     * We have to compile the project because some files need to be modified a bit in order to work when deployed
-     * In-place compilation, the files in the source folder will be modified/deleted and the output will be generated in the same folder
-     * For example auml files have to include their i18n data 
-     * /!\Warning/!\ This will modify/delete files in the source folder, make sure to know what you are doing !!!
-     * @param project current project
-     * @returns the path to the compiled project
-     */
-    public static async compileProject(targetPath: string): Promise<CompilationResult> {
-
-        let context: CompilationContext = { targetPath: targetPath, processes: {}, documents: {}, tables: {}, files: [], errors: [], warnings: [] };
-
-        // Rebuild manifest from cache if it exists, otherwise generate it from project files
-        console.log(chalk.cyan('→') + ' Generating manifest...');
-        const fullManifest = await this.generateManifest(context);
-        context.manifest = fullManifest;
-        ConsoleUtils.check(`Manifest generated (${fullManifest.processes.length} process(es), ${fullManifest.reactApplications?.length ?? 0} React app(s))`);
-
-        console.log(chalk.cyan('→') + ' Generating OpenAPI spec...');
-        const openApi = await OpenApiUtils.generateOpenApi(context);
-        if (openApi) ConsoleUtils.check('OpenAPI spec generated');
-
-        console.log(chalk.cyan('→') + ' Generating database schema...');
-        const dbSchema = await this.generateDbSchema(context);
-        if (dbSchema && dbSchema.trim() !== '') ConsoleUtils.check('Database schema generated');
-
-        // Compile package versions
-        //compiledProject.manifest.packages = await this.compileSdkPackages(compiledProject.manifest);
-        //TODO I don't like the idea of the cli fetching latest versions of each package, maybe they should be fixed ? or resolution happens at deployment ?
-        // --> the problem is specific to auml components which we'll probably get rid of
-
-        // Compile auml files
-        //await this.compileAumlFiles(compiledProject.manifestCache, compiledProject);
-        //TODO aka add i18n into the files, I think we could find a better way to do that, or at least only add relevant i18n
-        // --> the problem is specific to auml components which we'll probably get rid of
-
-        //TODO i18n for React apps
-
-        // Build React apps if any
-        const reactApps = fullManifest.reactApplications ?? [];
-        for(let reactApp of reactApps) {
-            
-            try
-            {
-                console.log(chalk.cyan('→') + ` Building React app "${reactApp.applicationName}"...`);
-                const appPath = path.join(targetPath, reactApp.file);
-                const buildPath = await BuildUtils.buildApp2(appPath);
-                
-                // The build result is generated in .codenotch/appname-dist, we need to adapt the manifest to point to the generated index.html file
-                reactApp.file = StringUtils.toRelativePath(path.join(buildPath, 'index.html'), targetPath);
-                ConsoleUtils.check(`React app "${reactApp.applicationName}" built`);
-            }
-            catch(e)
-            {
-                context.errors.push(`Failed to build React application "${reactApp.applicationName}": ${e instanceof Error ? e.message : String(e)}`);
-            }
-        }
-
-        // Create/update the files
-        FileUtils.writeFileSync(path.join(targetPath, MANIFEST_FILE_NAME), JSON.stringify(fullManifest, null, 4));
-
-        const dbSchemaPath = path.join(targetPath, DB_SCHEMA_FILE_NAME);
-        if (await FileUtils.exists(dbSchemaPath)) {
-            FileUtils.delete(dbSchemaPath);
-        }
-        if(dbSchema && dbSchema.trim() !== '')
-            FileUtils.writeFileSync(dbSchemaPath, dbSchema);
-       
-        const openapiPath = path.join(targetPath, OPENAPI_FILE_NAME);
-        if (await FileUtils.exists(openapiPath)) {
-            FileUtils.delete(openapiPath);
-        }
-        if(openApi)
-            FileUtils.writeFileSync(openapiPath, JSON.stringify(openApi, null, 4));
-
-        // Remove manifest cache
-        FileUtils.delete(path.join(targetPath, MANIFEST_CACHE_FILE_NAME));
-
-        // Remove .npmrc if exists, we don't want to expose it
-        FileUtils.delete(path.join(targetPath, '.npmrc'));
-
-        if (context.errors.length > 0) {
-            console.log(chalk.red(`Compilation finished with ${context.errors.length} error(s)`));
-        } else {
-            ConsoleUtils.check('Compilation complete');
-        }
-
-        return {
-            errors: context.errors,
-            warnings: context.warnings
-        };
-    }
-
-    /**
-     * Execute the compilation step needed for the tests to execute properly, skipping steps that are not needed for tests (like building React apps)
-     * 
-     * @param project current project
-     * @returns the path to the compiled project
-     */
-    public static async compileTestProject(targetPath: string): Promise<CompilationResult> {
-
-        let context: CompilationContext = { targetPath: targetPath, processes: {}, documents: {}, tables: {}, files: [], errors: [], warnings: [] };
-
-        // Rebuild manifest from cache if it exists, otherwise generate it from project files
-        const fullManifest = await this.generateManifest(context);
-        context.manifest = fullManifest;
-
-        const dbSchema = await this.generateDbSchema(context);
-
-        // Create/update the files
-        FileUtils.writeFileSync(path.join(targetPath, MANIFEST_FILE_NAME), JSON.stringify(fullManifest, null, 4));
-        FileUtils.writeFileSync(path.join(targetPath, DB_SCHEMA_FILE_NAME), dbSchema);
-
-        return {
-            errors: context.errors,
-            warnings: context.warnings
-        };
-    }
-
-    static async generateDbSchema( context: CompilationContext): Promise<string> {
-
-        try
-        {
-            if(!context.manifest) {
-                throw new Error("Manifest is required to generate db schema");
-            }
-
-            let tablesResult: TableDefinition[] = Object.values(context.tables);
-
-            // Update db schema
-            let dbSchema = ProjectCompilationUtils.GetXMLFromTableDefinition(tablesResult, context.manifest.version);
-
-            return dbSchema;
-        }
-        catch (e) {
-            context.errors.push(`Failed to generate database schema: ${e instanceof Error ? e.message : String(e)}`);
-            return '';
-        }
-    }
-
-    static GetXMLFromTableDefinition(definitions: TableDefinition[], version: string = "0.0.1"): string {
-
-        let DatabaseSchema: any = {
-            Tables: {
-                Table: []
-            },
-            "@": { Version: version }
-        };
-
-        definitions.forEach(definition => {
-            let definitionModel: any = {
-                "@": {
-                    Name: definition.Name,
-                    Description: definition.Description
-                },
-                Id: {
-                    "@": {
-                        Name: definition.Id.Name,
-                    }
-                },
-                CreatedAt: {
-                    "@": {
-                        Name: definition.CreatedAt.Name,
-                    }
-                },
-                UpdatedAt: {
-                    "@": {
-                        Name: definition.UpdatedAt.Name,
-                    }
-                }
-            }
-            definition.Fields?.forEach(field => {
-                let resultfield: any = {
-                    "@": Object.assign({}, field)
-                }
-                delete resultfield["@"].Type;
-
-                if (field.Type === FieldTypes.Enum) {
-                    resultfield["Value"] = resultfield["@"].Value;
-                    delete resultfield["@"].Value;
-                }
-
-                if (Array.isArray(definitionModel[field.Type])) {
-                    definitionModel[field.Type].push(resultfield);
-                } else if (definitionModel[field.Type]) {
-                    definitionModel[field.Type] = [definitionModel[field.Type]];
-                    definitionModel[field.Type].push(resultfield);
-                } else {
-                    definitionModel[field.Type] = resultfield
-                }
-            })
-            DatabaseSchema.Tables.Table.push(definitionModel)
-
-        });
-
-        let result = parse("DatabaseSchema", DatabaseSchema, { format: { doubleQuotes: true } })
-        return result;
-    }
-
-    /*
-    private static async compileAumlFiles(manifest: IWorkspaceCache, workspace: IWorkspaceRoot) {
-
-        // Auml files need to include their i18n data
-        let globali18ns = await I18nUtils.getCompiledGlobali18n(workspace, true);
-
-        await I18nUtils.injectI18nIntoFiles(manifest.applications.map(x => x.file), workspace, globali18ns.values, globali18ns.files);
-
-        if (manifest.expressComponents)
-            await I18nUtils.injectI18nIntoFiles(manifest.expressComponents.map((x: any) => x.file), workspace, globali18ns.values, globali18ns.files);
-
-        if (manifest.pdfs)
-            await I18nUtils.injectI18nIntoFiles(manifest.pdfs.map(x => x.file), workspace, globali18ns.values, globali18ns.files);
-
-        if (manifest.htmls)
-            await I18nUtils.injectI18nIntoFiles(manifest.htmls.map(x => x.file), workspace, globali18ns.values, globali18ns.files);
-
-        if (manifest.emails)
-            await I18nUtils.injectI18nIntoFiles(manifest.emails.map(x => x.file), workspace, globali18ns.values, globali18ns.files);
-
-
-        // Assets can also contain auml files
-        let assetsPath = workspace + '/assets';
-        var assetFiles = await ElectronUtil.getFileSystem(assetsPath).getAllFilesFromPath(assetsPath);
-        var aumlAssetsFiles = assetFiles
-            .filter(x => x.endsWith(".auml")) // We only want auml files
-            .map(x => x.replace(workspace.path, '')); // Remove the project path part
-        await I18nUtils.injectI18nIntoFiles(aumlAssetsFiles, workspace, globali18ns.values, globali18ns.files);
-    }
-    */
-
-    /**
-     * Will lock the version of all packages that use the "latest"
-     */
-    /* TODO
-    private static async compileSdkPackages(manifest: IScenarioProjectManifest): Promise<{ [packageSource: string]: string }> {
-        let results: {
-            [packageSource: string]: string;
-        } = {};
-
-        for (let packageKey of Object.keys(manifest.packages)) {
-
-            let version = manifest.packages[packageKey];
-            if (version === "latest") {
-                // We need to lock the version of all packages that use the "latest"
-                // because otherwise we expose ourselves to a lot of potential problems due to unexpected changes in our dependencies
-
-                // Get the latest version from the table storage
-                var split = packageKey.split('/');
-
-                let company = "";
-                let packageName = split[0];
-
-                if (split.length === 2) {
-                    company = split[0].substring(1);
-                    packageName = split[1];
-                }
-
-                let latestVersion = await PackageUtils.getPackageLatestVersion(packageName, version, company);
-
-                results[packageKey] = latestVersion;
-            }
-            else {
-                results[packageKey] = version;
-            }
-        }
-
-        return results;
-    }
-    */
-
-    public static getManifestFileType(file: string) {
-        file = file.toLowerCase();
-        let fileType: 'table' | 'bpmn' | 'auml' | 'document' | 'script' | 'jsxtsx' | 'i18n' | '' =
-            file.endsWith('.table') ? 'table' :
-                file.endsWith('.bpmn') ? 'bpmn' :
-                    file.endsWith('.auml') ? 'auml' :
-                        file.endsWith('.jschema') ? 'document' :
-                            file.endsWith('.tsx') ? 'jsxtsx' :
-                                file.endsWith('.jsx') ? 'jsxtsx' :
-                                    file.endsWith('.i18n.csv') ? 'i18n' :
-                                        file.endsWith('.js') ? 'script' : '';
-        return fileType;
-    }
-
-    /**
-     * Generate the full project manifest
-     * Uses the manifest cache if available, otherwise read the project files to generate the full manifest
-     */
-    public static async generateManifest(context: CompilationContext): Promise<ProjectManifest> {
-        
-        const projectPath = context.targetPath;
-
-        // Obtain the manifest, this part only contains user defined properties, the rest will be generated from files or taken from the cache
-        let manifest = await FileUtils.readJsonFileAsync<ProjectManifest>(path.join(projectPath, MANIFEST_FILE_NAME));
-        if(!manifest) {
-            throw new Error("Cannot find manifest file in project");
-        }
-
-        // Ensure arrays are defined
-        manifest.postInstallationProcesses = manifest.postInstallationProcesses ?? [];
-        manifest.languages = manifest.languages ?? [];
-        manifest.dependencies = manifest.dependencies ?? [];
-        manifest.packages = manifest.packages ?? [];
-        manifest.roles = manifest.roles ?? [];
-        manifest.reactApplications = manifest.reactApplications ?? [];
-        manifest.apis = manifest.apis ?? [];
-        manifest.applications = manifest.applications ?? [];
-        manifest.emails = manifest.emails ?? [];
-        manifest.htmls = manifest.htmls ?? [];
-        manifest.expressComponents = manifest.expressComponents ?? [];
-        manifest.pdfs = manifest.pdfs ?? [];
-        manifest.scripts = manifest.scripts ?? [];
-        manifest.tableDataSources = manifest.tableDataSources ?? [];
-        manifest.documentDataSources = manifest.documentDataSources ?? [];
-        manifest.processes = manifest.processes ?? [];
-
-
-        // Ensure version is defined
-        if ((manifest.version ?? '').trim() === '') {
-            manifest.version = '0.0.1';
-        }
-
-        // Ensure default roles are existings
-        if (manifest.roles.find((c: any) => c.name.toLowerCase() === 'dev') === undefined) {
-            manifest.roles.push({
-                name: "Dev",
-                description: 'Role used for developpers.'
-            });
-        }
-        if (manifest.roles.find((c: any) => c.name.toLowerCase() === 'admin') === undefined) {
-            manifest.roles.push({
-                name: "Admin",
-                description: 'Role used for administrators.'
-            });
-        }
-
-        // Add default languages if none has been defined yet
-        if (manifest.languages.length === 0) {
-            manifest.languages = ["en"]
-        }
-
-        /* This is more optimized yes, but it lead to problems difficult to debug as it behaves differently depending on the cache, better to have a predictable behaviour
-        try
-        {
-            let manifestCache = context.ignoreCache ? null : await FileUtils.readJsonFileAsync<ProjectManifest>(path.join(projectPath, MANIFEST_CACHE_FILE_NAME));
-
-            // If a cache is present, skip discovering local files, typically inside the ide
-            if(manifestCache) {
-
-                manifest = {
-                    ...manifest,
-                    ...manifestCache
-                }
-
-                // We still need to populate the context
-                //TODO
-
-                return manifest; 
-            }
-        }
-        catch {}
-        */
-        
-        // No cache, we need to discover files to generate the full manifest
-        const projectFiles = FileUtils.getAllFilesFromPath(projectPath, ['node_modules', '.codenotch', '.git', 'dist', 'build', 'out']);
-        context.files = projectFiles;
-
-        //#region tables
-        manifest.tableDataSources = [];
-
-        // Read all tables
-        let tablesFiles = projectFiles.filter(file => file.endsWith(".table"));
-        for (let i = 0; i < tablesFiles.length; i++) {
-            let tablefile = tablesFiles[i];
-            let tableDefinition = (await FileUtils.readJsonFileAsync<TableDefinition>(tablefile))!;
-            manifest.tableDataSources.push({
-                file: StringUtils.toRelativePath(tablefile, projectPath),
-                name: tableDefinition.Name,
-            });
-
-            context.tables[tableDefinition.Name] = tableDefinition;
-        }
-        //#endregion
-
-        //#region documents
-        manifest.documentDataSources = [];
-        let datastores = projectFiles.filter(file => file.endsWith(".jschema"));
-        for (let i = 0; i < datastores.length; i++) {
-            let datastoreFile = datastores[i];
-            let document = (await FileUtils.readJsonFileAsync<AbstractRecordContainer>(datastoreFile))!;
-            manifest.documentDataSources.push({
-                file: StringUtils.toRelativePath(datastoreFile, projectPath),
-                name: document.name,
-            });
-
-            context.documents[document.name] = document;
-        }
-        //#endregion
-
-        //#region processes
-        manifest.processes = [];
-        manifest.apis = [];
-
-        //TODO handle dependencies too ? for now, it will issue warnings for external calls it cannot verify
-        let serviceName = manifest.serviceName;
-        let provider: IWorkflowDataProvider = new StaticWorkflowDataProvider(
-            [manifest], 
-            serviceName, 
-            Object.values(context.tables).map(t => ({ service: serviceName, model: t })),
-            Object.values(context.documents).map(d => ({ service: serviceName, model: d }))
-        );
-
-        let bpmns = projectFiles.filter(file => file.endsWith(".bpmn"));
-        for (let i = 0; i < bpmns.length; i++) {
-            let bpmnFile = bpmns[i];
-            await this.generateManifestBpmn(bpmnFile, projectPath, manifest, provider, context);
-        }
-
-        // Ensure all processes defined here are really in the project
-        manifest.postInstallationProcesses = manifest.postInstallationProcesses!.filter((x: any) => manifest!.processes.find((y: any) => y.processName === x.processName) !== undefined);
-
-        //#endregion
-
-        //#region jsxtsx
-        manifest.reactApplications = [];
-
-        // Each file ending with .jsx or .tsx with a .manifest.json is considered as a React application
-        const jsxs = projectFiles.filter(file => file.endsWith(".jsx"));
-        const tsxs = projectFiles.filter(file => file.endsWith(".tsx"));
-        let jsxtsxs = [...jsxs, ...tsxs];
-        for (let i = 0; i < jsxtsxs.length; i++) {
-            await this.generateManifestReactApp(jsxtsxs[i], projectPath, manifest);
-        }
-
-        //#endregion
-
-        /* TODO see if we need that, shouldn't the react build already contain the translations§
-        let isNodeApp = await FileUtils.exists(FileUtils.normalize(`${project.path}/package.json`));
-        //#region i18n
-
-        if (isNodeApp && (updateAll || fileType === 'i18n')) {
-
-            let allI18nValues = await I18nUtils.getAllI18nFiles(project.path);
-            let codenotchOverridePath = StringUtils.normalizePath(`${project.path}/typings/i18n.d.ts`);
-            let translations: { key: string; argumentCount: number; }[] = [];
-            for (let item of allI18nValues) {
-                let allValues = item.values.map(c => c.value).join(' ');
-                let argMatchs = [...allValues.matchAll(/({([\d ]*)})/gm)];
-                let argCount = 0;
-                for (let i = 0; i < argMatchs.length; i++) {
-                    if (allValues.includes(`{${i}}`)) {
-                        argCount++;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                translations.push({
-                    key: item.key,
-                    argumentCount: argCount
-                });
-            }
-            translations = translations.sort((a, b) => a.key.localeCompare(b.key));
-            let codenotchOverride = TsxCompiler.createCodenotchReactI18NOverride(translations);
-            await FileUtils.writeFileAsync(codenotchOverridePath, codenotchOverride);
-         
-         
-           TsxCompiler.createFile(codenotchOverridePath, codenotchOverride);
-        }
-
-        if (processChanged && isNodeApp) {
-            let codenotchOverridePath = StringUtils.normalizePath(`${project.path}/typings/process.d.ts`);
-            let codenotchOverride = TsxCompiler.createCodenotchReactProcessOverride(manifestCache.processes);
-            await IdeServices.Files.writeFileAsync(codenotchOverridePath, codenotchOverride);
-            TsxCompiler.createFile(codenotchOverridePath, codenotchOverride);
-        }
-        */
-
-        //#endregion
-
-        //#region auml
-        manifest.emails = [];
-        manifest.pdfs = [];
-        manifest.applications = [];
-        manifest.expressComponents = [];
-        manifest.htmls = [];
-
-        let aumls = projectFiles.filter(file => file.endsWith(".auml"));
-        for (let i = 0; i < aumls.length; i++) {
-            let aumlFile = aumls[i];
-            await this.generateManifestAumlApp(aumlFile, projectPath, manifest);
-        }
-
-        // Try add a default index 
-        let hasIndexApp = (manifest.index ?? '').trim() !== '';
-        if (hasIndexApp === false) {
-            manifest.index = manifest.applications.length > 0 ? manifest.applications[0].applicationName : undefined;
-        }
-        else {
-            let appExists = manifest.applications.find(c => c.applicationName === manifest?.index) !== undefined;
-            if (appExists === false) {
-                manifest.index = undefined;
-            }
-        }
-
-        //#endregion
-
-        //#region scripts
-        manifest.scripts = [];
-        let scripts = projectFiles.filter(file => file.endsWith(".js") &&
-            file.endsWith(".test.js") === false &&
-            file.endsWith(".spec.js") === false &&
-            file.endsWith(".config.js") === false); 
-
-        for (let i = 0; i < scripts.length; i++) {
-            let scriptFile = scripts[i];
-            manifest.scripts!.push({
-                file: StringUtils.toRelativePath(scriptFile, projectPath)
-            });
-        }
-        //#endregion
-
-        return manifest;
-    }
-
-    static async parseBpmn(rawBpmn: string, provider: IWorkflowDataProvider): Promise<IProcess | null> {
-       
-        let validator = new BpmnToWorkflowDeserializer();
-        let result = await validator.parse(rawBpmn, provider);
-
-        //TODO handle warnigns and errors with BpmnValidator
-        //return result.bpmn;
-
-        return result ?? null;
-
-    }
-
-    private static async generateManifestBpmn(filepath: string, projectPath: string, manifest: ProjectManifest, provider: IWorkflowDataProvider, compilation: CompilationContext) {
-        try {
-
-            let bpmnRaw = (await FileUtils.readFileAsync(filepath))!;
-
-            let model: IProcess | null = null;
-            try
-            {
-                model = await this.parseBpmn(bpmnRaw, provider);
-                if(!model) {
-                    compilation.errors.push(`Cannot parse bpmn file ${filepath}`);
-                    return;
-                }
-            }
-            catch(e)
-            {
-                compilation.errors.push(`Error while parsing bpmn file ${filepath}: ${(e as Error).message}`);
-                return;
-            }
-
-            let processHash = await StringUtils.sha256(bpmnRaw);
-
-            let pools = model.items.filter((e) => e.type === WorkflowItemType.Pool) as IWorkflowPool[];
-
-            // If there is only one process (ie no pools) we can rely on model.processId
-            if (!pools || pools.length === 0) {
-                // Default pool
-                let pool: IWorkflowPool = 
-                {
-                    type: WorkflowItemType.Pool,
-                    orientation: 'horizontal',
-                    id: "defaultPool",
-                    processId: model.processId,
-                    name: model.processId,
-                    lanes: [],
-                    isTransaction: false,
-                    ignoreLogs: false,
-                    minThreads: 1,
-                    maxThreads: -1,
-                    poolType: WorkflowPoolType.Public,
-                    x: 0,
-                    y: 0,
-                    width: 800,
-                    height: 600,
-                    priority: WorkflowPoolPriority.Medium
-                };
- 
-                this.generateManifestProcess(filepath, projectPath, pool, model.items, processHash, manifest);
-
-                compilation.processes[model.processId] = model;
-            }
-            else {
-                // Otherwise, we need to register each process
-                for (let pool of pools) {
-                    //TODO other way than checking position ?
-                    //let poolElements = model.elements.filter((e: any) => e instanceof BpmnNodeModel && WorkflowUtils.belongsToPoolOrLane(pool, e));
-                    let poolElements = model.items; 
-                    this.generateManifestProcess(filepath, projectPath, pool, poolElements, processHash, manifest);
-
-                    compilation.processes[pool.processId] = model;
-                }
-            }
-
-            
-        }
-        catch (e) {
-            compilation.errors.push(`Error while parsing bpmn file ${filepath}: ${(e as Error).message}`);
-        }
-    }
-
-    private static generateManifestProcess(bpmnFilePath: string, projectPath: string, pool: IWorkflowPool, processElements: IWorkflowItem[], processHash: string, manifest: ProjectManifest) {
-        try {
-
-            // Process and StartEvents
-            let process = new ProjectManifestProcess();
-            process.file = StringUtils.toRelativePath(bpmnFilePath, projectPath);
-
-            process.processName = `${pool.processId}`;
-            let startEvents = processElements.filter(c =>
-                c.type ===  WorkflowItemType.StartEvent ||
-                c.type === WorkflowItemType.SignalStartEvent ||
-                c.type === WorkflowItemType.ApiStartEvent ||
-                c.type === WorkflowItemType.WebhookStartEvent ||
-                c.type === WorkflowItemType.TimerStartEvent ||
-                c.type === WorkflowItemType.MessageStartEvent ||
-                c.type === WorkflowItemType.StandardStartEvent);
-
-            let endEvents = processElements.filter(c =>
-                c.type === WorkflowItemType.EndEvent ||
-                c.type === WorkflowItemType.ErrorEndEvent ||
-                c.type === WorkflowItemType.CancelEndEvent ||
-                c.type === WorkflowItemType.SignalEndEvent ||
-                c.type === WorkflowItemType.MessageEndEvent ||
-                c.type === WorkflowItemType.WebhookEndEvent ||
-                c.type === WorkflowItemType.StandardEndEvent ||
-                c.type === WorkflowItemType.TerminateEndEvent ||
-                c.type === WorkflowItemType.EscalationEndEvent ||
-                c.type === WorkflowItemType.CompensationEndEvent ||
-                c.type === WorkflowItemType.CallbackEndEvent);
-
-            let signals = processElements.filter(c =>
-                c.type === WorkflowItemType.SignalStartEvent ||
-                c.type === WorkflowItemType.SignalEndEvent ||
-                c.type === WorkflowItemType.ThrowSignalIntermediateEvent ||
-                c.type === WorkflowItemType.CatchSignalIntermediateEvent);
-
-            startEvents.forEach(startEvent => {
-                let processStart = new ProjectManifestProcessStartEvent();
-                processStart.kind = 'not implemented';
-                switch (startEvent.type) {
-                    case WorkflowItemType.StartEvent: processStart.kind = 'manual'; break;
-                    case WorkflowItemType.SignalStartEvent: processStart.kind = 'signal'; break;
-                    case WorkflowItemType.ApiStartEvent: processStart.kind = 'api'; break;
-                    case WorkflowItemType.WebhookStartEvent: processStart.kind = 'webhook'; break;
-                    case WorkflowItemType.TimerStartEvent: processStart.kind = 'timer'; break;
-                    case WorkflowItemType.MessageStartEvent: processStart.kind = 'message'; break;
-                    case WorkflowItemType.StandardStartEvent: processStart.kind = 'standard'; break;
-                }
-                processStart.nodeId = startEvent.id;
-                processStart.scope = pool.type;
-
-                //TODO This not yet supported
-                //processStart.roles = WorkflowUtils.getRolesOfStartNode(startEvent as BpmnNodeModel, pool.swimlanes);
-
-                let evtNode = startEvent as IWorkflowEvent;
-                let eventDefinitions = evtNode.eventDefinitions;
-
-                // Only take the first definition into account
-                //TODO ?
-                if (eventDefinitions && eventDefinitions.length > 0) {
-
-                    let evtDef = eventDefinitions[0] as IWorkflowStandardEventDefinition;
-                    if (evtNode.outputs && evtNode.outputs.length > 0) {
-                        
-                        let parameters = evtNode.outputs[0].outputVariables;
-                        let input: IVariable = 
-                        {
-                            id: 'input',
-                            value: '',
-                            name: 'input',
-                            type: VariableType.object,
-                            objectType: parameters,
-                            isSecret: false
-                        };
-
-                        processStart.input = ProjectCompilationUtils.ProcessVariableToJsonSchema(input);
-                    }
-                    else {
-                        processStart.input = {};
-                    }
-                }
-
-                process.startEvents.push(processStart);
-            });
-
-            signals.forEach(signal => {
-
-                let processSignal = new ProjectManigestSignal();
-                processSignal.type = 'not implemented';
-
-                let eventNode = (signal as IWorkflowEvent);
-
-                let signalModel = eventNode.eventDefinitions[0] as IWorkflowSignalEventDefinition;
-                processSignal.signalId = signalModel.signalId;
-
-                switch (signal.type) {
-                    case WorkflowItemType.SignalStartEvent: processSignal.type = 'start'; break;
-                    case WorkflowItemType.SignalEndEvent: processSignal.type = 'end'; break;
-                    case WorkflowItemType.ThrowSignalIntermediateEvent: processSignal.type = 'throw'; break;
-                    case WorkflowItemType.CatchSignalIntermediateEvent: processSignal.type = 'catch'; break;
-                }
-
-                process.signals.push(processSignal);
-            });
-
-            // Create a merged output from all end events of the process
-            //let mergedOutput: CodeVariable[] = [];
-
-            //TODO not sure we need the end event, we don't really use it and it takes space in the manifest 
-            /*
-            endEvents.forEach(endEvent => {
-
-                let eventDefinitions = (endEvent as EventNodeModel).eventDefinitions;
-
-                // We are only interested in data definition, other definitions don't change the process output 
-                let dataDef = eventDefinitions.find((x: any) => x instanceof DataEventDefinitionModel) as DataEventDefinitionModel;
-
-                // For api end events...
-                if (dataDef === undefined) {
-                    dataDef = eventDefinitions.find((x: any) => x instanceof CallbackEventDefinitionModel) as CallbackEventDefinitionModel;
-                }
-
-                // Add parameters to the merged output
-                if (dataDef)
-                    mergedOutput = mergedOutput.concat(dataDef.parameters as any);
-            });
-            
-
-            // Remove duplicates (variables with the same name)
-            let seen = new Set();
-            mergedOutput = mergedOutput.filter(x => seen.has(x.name) ? false : seen.add(x.name));
-
-            let output: CodeVariable = {
-                name: 'output',
-                type: VariableType.MAP,
-                childVariables: mergedOutput,
-                listElement: null,
-                isSecret: false,
-                enum: null
-            };
-            process.endEvent = ProjectCompilationUtils.ProcessVariableToJsonSchema(output);
-            */
-
-            process.priority = pool.priority;
-            process.minThreads = pool.minThreads;
-            process.maxThreads = pool.maxThreads;
-
-            // Each process has a unique hash that can be used to optimize the deployment
-            //@ts-ignore
-            process.hash = processHash;
-
-            manifest.processes.push(process);
-
-            // Apis
-            processElements.forEach(e => {
-                
-                let eventDefinitions = (e as IWorkflowEvent).eventDefinitions;
-                if(eventDefinitions)
-                {
-                    eventDefinitions.forEach((def: any) => {
-                        if(def.route && def.method) {
-                            let api = new ProjectManifestApi();
-                            api.method = def.method;
-                            api.path = def.route
-                            api.bpmn = process.processName;
-                            api.startNode = e.id;
-                            api.accept = def.accept;
-
-                            (api as any).whitelist = def.whitelist;
-
-                            api.priority = pool.priority;
-                            api.minThreads = pool.minThreads;
-                            api.maxThreads = pool.maxThreads;
-
-                            def.parameters.forEach((p: any) => {
-                                // TODO ?
-                            });
-                            manifest.apis.push(api);
-                        }
-
-                    });
-                }
-            });
-
-
-        }
-        catch (e) {
-            console.log("Cannot save bpmn", bpmnFilePath, e)
-        }
-    }
-
-    public static ProcessVariableToJsonSchema(variable: IVariable): JSONSchema7 {
-        let schema: JSONSchema7 = {};
-
-        schema.type = ProjectCompilationUtils.ProcessVariableTypeToJsonSchemaTypeName(variable.type);
-
-        if (variable.type === VariableType.object) {
-            schema.properties = {};
-            for (let child of variable.objectType ?? []) {
-                schema.properties[child.name] = ProjectCompilationUtils.ProcessVariableToJsonSchema(child);
-            }
-        }
-        else if (variable.type === VariableType.array) {
-            if (variable.arrayType)
-                schema.items = ProjectCompilationUtils.ProcessVariableToJsonSchema(variable.arrayType);
-        }
-
-        return schema;
-    }
-
-    public static ProcessVariableTypeToJsonSchemaTypeName(type: VariableType): JSONSchema7TypeName {
-        switch (type) {
-            case VariableType.string:
-                return "string";
-            case VariableType.int:
-                return "integer";
-            case VariableType.float:
-                return "number";
-            case VariableType.bool:
-                return "boolean";
-            case VariableType.array:
-                return "array";
-            case VariableType.object:
-                return "object";
-            case VariableType.enum:
-                return "string";
-            case VariableType.function:
-                return "object";
-        }
-    }
-
-    private static async generateManifestReactApp(filePath: string, projectPath: string, manifest: ProjectManifest) {
-        try {
-            let ext = filePath.split('.').pop()!;
-            let manifestPath = filePath.replace(`.${ext}`, '.manifest.json');
-            if (await FileUtils.exists(manifestPath) === false) {
-                return;
-            }
-            let appManifest: ApplicationManifest = JSON.parse((await FileUtils.readFileAsync(manifestPath))!);
-            let fileName = StringUtils.getFilenameFromUri(filePath);
-            let reactAppmanifest = new ProjectManifestReactApplication();
-            reactAppmanifest.file = StringUtils.toRelativePath(filePath, projectPath);
-            reactAppmanifest.roles = appManifest.auml?.roles ?? [];
-            reactAppmanifest.scope = appManifest.auml?.scope ?? 'Public';
-            reactAppmanifest.applicationName = fileName.replace(`.${ext}`, '');
-            manifest.reactApplications = manifest.reactApplications ?? [];
-            manifest.reactApplications.push(reactAppmanifest);
-        }
-        catch (e) {
-            console.error("Cannot generateManifestReactApp", filePath, e);
-        }
-    }
-
-    private static async generateManifestAumlApp(filePath: string, projectPath: string, manifest: ProjectManifest) {
-        try {
-            // Read file
-
-            let auml = await FileUtils.readFileAsync(filePath);
-            if (!auml) {
-                return;
-            }
-
-            let fileName = filePath.includes("/") ? filePath.split("/").pop()! :
-                filePath.includes("\\") ? filePath.split("\\").pop()! :
-                    filePath;
-
-            // Figure out if this is an application or an express component
-
-            let trimmedAuml = auml.replace(/^\s+|\s+$/g, '');
-
-            if (trimmedAuml.startsWith("<Application")) {
-
-                // Application
-                let application = new ProjectManifestApplication();
-                application.file = StringUtils.toRelativePath(filePath, projectPath);
-                application.roles = []
-
-                let match = auml.match(/<Application[^>]*?Name="(.*?)"/);
-
-                application.applicationName = fileName.replace(".auml", "");
-                if (match) {
-
-                    let appName = match[1];
-                    if (appName) {
-                        application.applicationName = appName;
-                    }
-                }
-
-                // Roles are now defined manually in manifest editor
-                // Search for roles in the application
-                match = auml.match(/<Application[^>]*?Role="(.*?)"/);
-
-                if (match) {
-                    application.roles = [match[1]];
-                }
-
-                // Search for a scope in the application
-                match = auml.match(/<Application[^>]*?Scope="(.*?)"/);
-
-                if (match) {
-
-                    let scope = match[1];
-
-                    if (scope !== "Internal" && scope !== "External")
-                        application.scope = "Public"; // if scope is not recognized, default to public
-                    else
-                        application.scope = scope;
-                }
-                else {
-                    application.scope = "Public";
-                }
-
-                manifest.applications.push(application);
-            }
-            else if (trimmedAuml.startsWith("<Component")) {
-                let findComponentNameRegexp = /<Component[^>]*?Name="([\S]*?)"/m;
-
-                let match = auml.match(findComponentNameRegexp);
-
-                if (match) {
-                    // Express component
-                    let expressComponent = new ProjectManifestExpressComponent();
-                    expressComponent.componentName = match[1];
-                    expressComponent.file = StringUtils.toRelativePath(filePath, projectPath);
-                    manifest.expressComponents!.push(expressComponent);
-                }
-            }
-            else if (trimmedAuml.startsWith("<PDF")) {
-                let pdf = new ProjectManifestPdf();
-                pdf.name = fileName.replace(".auml", "");
-                pdf.file = StringUtils.toRelativePath(filePath, projectPath);
-                manifest.pdfs!.push(pdf)
-            }
-            else if (trimmedAuml.startsWith("<Email")) {
-                let email = new ProjectManifestEmail();
-                email.name = fileName.replace(".auml", "");
-                email.file = StringUtils.toRelativePath(filePath, projectPath);
-                manifest.emails!.push(email)
-            }
-            else if (trimmedAuml.startsWith("<HTML")) {
-                let html = new ProjectManifestHtml();
-                html.name = fileName.replace(".auml", "");
-                html.file = StringUtils.toRelativePath(filePath, projectPath);
-                manifest.htmls!.push(html)
-            }
-        }
-        catch (e) {
-            console.error("Cannot save auml", filePath, e);
-        }
-    }
-
-}