@codenotch/codenotch.cli 1.0.35 → 1.0.36

package/dist/utils/ProjectCompilationUtils.js

@@ -4,86 +4,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
-const Codenotch_1 = require("../models/Codenotch");
-const DbModels_1 = require("../models/DbModels");
 const FileUtils_1 = __importDefault(require("./FileUtils"));
-const OpenAPIUtils_1 = require("./OpenAPIUtils");
-const StringUtils_1 = __importDefault(require("./StringUtils"));
-const js2xmlparser_1 = require("js2xmlparser");
-const BuildUtils_1 = __importDefault(require("./BuildUtils"));
 const ConsoleUtils_1 = __importDefault(require("./ConsoleUtils"));
-const codenotch_core_workflow_1 = require("@codenotch/codenotch.core.workflow");
-const codenotch_core_1 = require("@codenotch/codenotch.core");
 const chalk_1 = __importDefault(require("chalk"));
 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";
 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
      */
     static async compileProject(targetPath) {
-        let context = { targetPath: targetPath, processes: {}, documents: {}, tables: {}, files: [], errors: [], warnings: [] };
+        // TODO: Generate kinda DB schema (read all .ts/.js files that declare a table)
+        // TODO: Generate openapi.json (read all .ts/.js files that declare a process)
+        // TODO: Generate ts files for i18n (one per *.i18n.csv)
+        const context = {
+            targetPath: targetPath,
+            files: FileUtils_1.default.getAllFilesFromPath(targetPath, ['node_modules', '.codenotch', '.git', 'dist', 'build', 'out', '.github']),
+            errors: [],
+            warnings: []
+        };
         // Rebuild manifest from cache if it exists, otherwise generate it from project files
         console.log(chalk_1.default.cyan('→') + ' Generating manifest...');
-        const fullManifest = await this.generateManifest(context);
-        context.manifest = fullManifest;
-        ConsoleUtils_1.default.check(`Manifest generated (${fullManifest.processes.length} process(es), ${fullManifest.reactApplications?.length ?? 0} React app(s))`);
-        console.log(chalk_1.default.cyan('→') + ' Generating OpenAPI spec...');
-        const openApi = await OpenAPIUtils_1.OpenApiUtils.generateOpenApi(context);
-        if (openApi)
-            ConsoleUtils_1.default.check('OpenAPI spec generated');
-        console.log(chalk_1.default.cyan('→') + ' Generating database schema...');
-        const dbSchema = await this.generateDbSchema(context);
-        if (dbSchema && dbSchema.trim() !== '')
-            ConsoleUtils_1.default.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_1.default.cyan('→') + ` Building React app "${reactApp.applicationName}"...`);
-                const appPath = path_1.default.join(targetPath, reactApp.file);
-                const buildPath = await BuildUtils_1.default.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_1.default.toRelativePath(path_1.default.join(buildPath, 'index.html'), targetPath);
-                ConsoleUtils_1.default.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_1.default.writeFileSync(path_1.default.join(targetPath, MANIFEST_FILE_NAME), JSON.stringify(fullManifest, null, 4));
-        const dbSchemaPath = path_1.default.join(targetPath, DB_SCHEMA_FILE_NAME);
-        if (await FileUtils_1.default.exists(dbSchemaPath)) {
-            FileUtils_1.default.delete(dbSchemaPath);
-        }
-        if (dbSchema && dbSchema.trim() !== '')
-            FileUtils_1.default.writeFileSync(dbSchemaPath, dbSchema);
-        const openapiPath = path_1.default.join(targetPath, OPENAPI_FILE_NAME);
-        if (await FileUtils_1.default.exists(openapiPath)) {
-            FileUtils_1.default.delete(openapiPath);
-        }
-        if (openApi)
-            FileUtils_1.default.writeFileSync(openapiPath, JSON.stringify(openApi, null, 4));
-        // Remove manifest cache
-        FileUtils_1.default.delete(path_1.default.join(targetPath, MANIFEST_CACHE_FILE_NAME));
+        context.manifest = await this.generateManifest(context);
+        ConsoleUtils_1.default.check(`Manifest generated`);
+        // Overwrite manifest
+        FileUtils_1.default.writeFileSync(path_1.default.join(targetPath, MANIFEST_FILE_NAME), JSON.stringify(context.manifest, null, 4));
         // Remove .npmrc if exists, we don't want to expose it
         FileUtils_1.default.delete(path_1.default.join(targetPath, '.npmrc'));
         if (context.errors.length > 0) {
@@ -104,167 +54,32 @@ class ProjectCompilationUtils {
      * @returns the path to the compiled project
      */
     static async compileTestProject(targetPath) {
-        let context = { targetPath: targetPath, processes: {}, documents: {}, tables: {}, files: [], errors: [], warnings: [] };
+        const context = { targetPath: targetPath, 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);
+        context.manifest = await this.generateManifest(context);
         // Create/update the files
-        FileUtils_1.default.writeFileSync(path_1.default.join(targetPath, MANIFEST_FILE_NAME), JSON.stringify(fullManifest, null, 4));
-        FileUtils_1.default.writeFileSync(path_1.default.join(targetPath, DB_SCHEMA_FILE_NAME), dbSchema);
+        FileUtils_1.default.writeFileSync(path_1.default.join(targetPath, MANIFEST_FILE_NAME), JSON.stringify(context.manifest, null, 4));
+        const dbSchema = await this.generateDbSchema(context);
+        if (dbSchema) {
+            FileUtils_1.default.writeFileSync(path_1.default.join(targetPath, DB_SCHEMA_FILE_NAME), dbSchema);
+        }
         return {
             errors: context.errors,
             warnings: context.warnings
         };
     }
     static async generateDbSchema(context) {
-        try {
-            if (!context.manifest) {
-                throw new Error("Manifest is required to generate db schema");
-            }
-            let tablesResult = 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, version = "0.0.1") {
-        let DatabaseSchema = {
-            Tables: {
-                Table: []
-            },
-            "@": { Version: version }
-        };
-        definitions.forEach(definition => {
-            let definitionModel = {
-                "@": {
-                    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 = {
-                    "@": Object.assign({}, field)
-                };
-                delete resultfield["@"].Type;
-                if (field.Type === DbModels_1.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 = (0, js2xmlparser_1.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;
+        // TODO: Generate DB schema (read all .ts/.js files that declare a table)
+        throw new Error('Not implemented.');
     }
-    */
     static getManifestFileType(file) {
         file = file.toLowerCase();
         let fileType = 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' : '';
+            file.endsWith('.jschema') ? 'document' :
+                file.endsWith('.tsx') ? 'jsxtsx' :
+                    file.endsWith('.jsx') ? 'jsxtsx' :
+                        file.endsWith('.i18n.csv') ? 'i18n' :
+                            file.endsWith('.js') ? 'script' : '';
         return fileType;
     }
     /**
@@ -274,27 +89,13 @@ class ProjectCompilationUtils {
     static async generateManifest(context) {
         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_1.default.readJsonFileAsync(path_1.default.join(projectPath, MANIFEST_FILE_NAME));
+        const manifest = await FileUtils_1.default.readJsonFileAsync(path_1.default.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';
@@ -316,535 +117,48 @@ class ProjectCompilationUtils {
         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_1.default.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_1.default.readJsonFileAsync(tablefile));
-            manifest.tableDataSources.push({
-                file: StringUtils_1.default.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_1.default.readJsonFileAsync(datastoreFile));
-            manifest.documentDataSources.push({
-                file: StringUtils_1.default.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 = new codenotch_core_workflow_1.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) => manifest.processes.find((y) => 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_1.default.toRelativePath(scriptFile, projectPath)
-            });
-        }
-        //#endregion
         return manifest;
     }
-    static async parseBpmn(rawBpmn, provider) {
-        let validator = new codenotch_core_workflow_1.BpmnToWorkflowDeserializer();
-        let result = await validator.parse(rawBpmn, provider);
-        //TODO handle warnigns and errors with BpmnValidator
-        //return result.bpmn;
-        return result ?? null;
-    }
-    static async generateManifestBpmn(filepath, projectPath, manifest, provider, compilation) {
-        try {
-            let bpmnRaw = (await FileUtils_1.default.readFileAsync(filepath));
-            let model = 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.message}`);
-                return;
-            }
-            let processHash = await StringUtils_1.default.sha256(bpmnRaw);
-            let pools = model.items.filter((e) => e.type === codenotch_core_workflow_1.WorkflowItemType.Pool);
-            // If there is only one process (ie no pools) we can rely on model.processId
-            if (!pools || pools.length === 0) {
-                // Default pool
-                let pool = {
-                    type: codenotch_core_workflow_1.WorkflowItemType.Pool,
-                    orientation: 'horizontal',
-                    id: "defaultPool",
-                    processId: model.processId,
-                    name: model.processId,
-                    lanes: [],
-                    isTransaction: false,
-                    ignoreLogs: false,
-                    minThreads: 1,
-                    maxThreads: -1,
-                    poolType: codenotch_core_workflow_1.WorkflowPoolType.Public,
-                    x: 0,
-                    y: 0,
-                    width: 800,
-                    height: 600,
-                    priority: codenotch_core_workflow_1.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.message}`);
-        }
-    }
-    static generateManifestProcess(bpmnFilePath, projectPath, pool, processElements, processHash, manifest) {
-        try {
-            // Process and StartEvents
-            let process = new Codenotch_1.ProjectManifestProcess();
-            process.file = StringUtils_1.default.toRelativePath(bpmnFilePath, projectPath);
-            process.processName = `${pool.processId}`;
-            let startEvents = processElements.filter(c => c.type === codenotch_core_workflow_1.WorkflowItemType.StartEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.SignalStartEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.ApiStartEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.WebhookStartEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.TimerStartEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.MessageStartEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.StandardStartEvent);
-            let endEvents = processElements.filter(c => c.type === codenotch_core_workflow_1.WorkflowItemType.EndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.ErrorEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.CancelEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.SignalEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.MessageEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.WebhookEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.StandardEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.TerminateEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.EscalationEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.CompensationEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.CallbackEndEvent);
-            let signals = processElements.filter(c => c.type === codenotch_core_workflow_1.WorkflowItemType.SignalStartEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.SignalEndEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.ThrowSignalIntermediateEvent ||
-                c.type === codenotch_core_workflow_1.WorkflowItemType.CatchSignalIntermediateEvent);
-            startEvents.forEach(startEvent => {
-                let processStart = new Codenotch_1.ProjectManifestProcessStartEvent();
-                processStart.kind = 'not implemented';
-                switch (startEvent.type) {
-                    case codenotch_core_workflow_1.WorkflowItemType.StartEvent:
-                        processStart.kind = 'manual';
-                        break;
-                    case codenotch_core_workflow_1.WorkflowItemType.SignalStartEvent:
-                        processStart.kind = 'signal';
-                        break;
-                    case codenotch_core_workflow_1.WorkflowItemType.ApiStartEvent:
-                        processStart.kind = 'api';
-                        break;
-                    case codenotch_core_workflow_1.WorkflowItemType.WebhookStartEvent:
-                        processStart.kind = 'webhook';
-                        break;
-                    case codenotch_core_workflow_1.WorkflowItemType.TimerStartEvent:
-                        processStart.kind = 'timer';
-                        break;
-                    case codenotch_core_workflow_1.WorkflowItemType.MessageStartEvent:
-                        processStart.kind = 'message';
-                        break;
-                    case codenotch_core_workflow_1.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;
-                let eventDefinitions = evtNode.eventDefinitions;
-                // Only take the first definition into account
-                //TODO ?
-                if (eventDefinitions && eventDefinitions.length > 0) {
-                    let evtDef = eventDefinitions[0];
-                    if (evtNode.outputs && evtNode.outputs.length > 0) {
-                        let parameters = evtNode.outputs[0].outputVariables;
-                        let input = {
-                            id: 'input',
-                            value: '',
-                            name: 'input',
-                            type: codenotch_core_1.VariableType.object,
-                            objectType: parameters,
-                            isSecret: false
-                        };
-                        processStart.input = ProjectCompilationUtils.ProcessVariableToJsonSchema(input);
-                    }
-                    else {
-                        processStart.input = {};
-                    }
-                }
-                process.startEvents.push(processStart);
-            });
-            signals.forEach(signal => {
-                let processSignal = new Codenotch_1.ProjectManigestSignal();
-                processSignal.type = 'not implemented';
-                let eventNode = signal;
-                let signalModel = eventNode.eventDefinitions[0];
-                processSignal.signalId = signalModel.signalId;
-                switch (signal.type) {
-                    case codenotch_core_workflow_1.WorkflowItemType.SignalStartEvent:
-                        processSignal.type = 'start';
-                        break;
-                    case codenotch_core_workflow_1.WorkflowItemType.SignalEndEvent:
-                        processSignal.type = 'end';
-                        break;
-                    case codenotch_core_workflow_1.WorkflowItemType.ThrowSignalIntermediateEvent:
-                        processSignal.type = 'throw';
-                        break;
-                    case codenotch_core_workflow_1.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));
+}
+exports.default = ProjectCompilationUtils;
+class TypescriptUtils {
+    /**
+     * Read TS table definition file like:
+     * ```ts
+        import { defineEntity, type InferEntity, p } from '@codenotch/orm';
+
+        export const User = defineEntity({
+            name: 'User',
+            properties: {
+                id: p.integer().primary(),
+                fullName: p.string(),
+                email: p.string()
+            },
+        });
 
-            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.eventDefinitions;
-                if (eventDefinitions) {
-                    eventDefinitions.forEach((def) => {
-                        if (def.route && def.method) {
-                            let api = new Codenotch_1.ProjectManifestApi();
-                            api.method = def.method;
-                            api.path = def.route;
-                            api.bpmn = process.processName;
-                            api.startNode = e.id;
-                            api.accept = def.accept;
-                            api.whitelist = def.whitelist;
-                            api.priority = pool.priority;
-                            api.minThreads = pool.minThreads;
-                            api.maxThreads = pool.maxThreads;
-                            def.parameters.forEach((p) => {
-                                // TODO ?
-                            });
-                            manifest.apis.push(api);
-                        }
-                    });
-                }
-            });
-        }
-        catch (e) {
-            console.log("Cannot save bpmn", bpmnFilePath, e);
-        }
-    }
-    static ProcessVariableToJsonSchema(variable) {
-        let schema = {};
-        schema.type = ProjectCompilationUtils.ProcessVariableTypeToJsonSchemaTypeName(variable.type);
-        if (variable.type === codenotch_core_1.VariableType.object) {
-            schema.properties = {};
-            for (let child of variable.objectType ?? []) {
-                schema.properties[child.name] = ProjectCompilationUtils.ProcessVariableToJsonSchema(child);
-            }
-        }
-        else if (variable.type === codenotch_core_1.VariableType.array) {
-            if (variable.arrayType)
-                schema.items = ProjectCompilationUtils.ProcessVariableToJsonSchema(variable.arrayType);
-        }
-        return schema;
+        export type IUser = InferEntity<typeof User>;
+     * ```
+     *
+     * And returns the table structure(s) (can have multiple table in one file)
+     */
+    static async parseTablesFromScript(ts) {
+        // TODO
+        return [];
     }
-    static ProcessVariableTypeToJsonSchemaTypeName(type) {
-        switch (type) {
-            case codenotch_core_1.VariableType.string:
-                return "string";
-            case codenotch_core_1.VariableType.int:
-                return "integer";
-            case codenotch_core_1.VariableType.float:
-                return "number";
-            case codenotch_core_1.VariableType.bool:
-                return "boolean";
-            case codenotch_core_1.VariableType.array:
-                return "array";
-            case codenotch_core_1.VariableType.object:
-                return "object";
-            case codenotch_core_1.VariableType.enum:
-                return "string";
-            case codenotch_core_1.VariableType.function:
-                return "object";
-        }
+    /**
+     * Find all file (recursivly) in a given folder (workspacePath) that contains a table declaration ('defineEntity').
+     */
+    static async discoverTableFiles(workspacePath) {
     }
-    static async generateManifestReactApp(filePath, projectPath, manifest) {
-        try {
-            let ext = filePath.split('.').pop();
-            let manifestPath = filePath.replace(`.${ext}`, '.manifest.json');
-            if (await FileUtils_1.default.exists(manifestPath) === false) {
-                return;
-            }
-            let appManifest = JSON.parse((await FileUtils_1.default.readFileAsync(manifestPath)));
-            let fileName = StringUtils_1.default.getFilenameFromUri(filePath);
-            let reactAppmanifest = new Codenotch_1.ProjectManifestReactApplication();
-            reactAppmanifest.file = StringUtils_1.default.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);
-        }
+    /**
+     * Find all file (recursivly) in a given folder (workspacePath) that contains a table declaration ('defineDocument').
+     */
+    static async discoverDocumentFiles(workspacePath) {
     }
-    static async generateManifestAumlApp(filePath, projectPath, manifest) {
-        try {
-            // Read file
-            let auml = await FileUtils_1.default.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 Codenotch_1.ProjectManifestApplication();
-                application.file = StringUtils_1.default.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 Codenotch_1.ProjectManifestExpressComponent();
-                    expressComponent.componentName = match[1];
-                    expressComponent.file = StringUtils_1.default.toRelativePath(filePath, projectPath);
-                    manifest.expressComponents.push(expressComponent);
-                }
-            }
-            else if (trimmedAuml.startsWith("<PDF")) {
-                let pdf = new Codenotch_1.ProjectManifestPdf();
-                pdf.name = fileName.replace(".auml", "");
-                pdf.file = StringUtils_1.default.toRelativePath(filePath, projectPath);
-                manifest.pdfs.push(pdf);
-            }
-            else if (trimmedAuml.startsWith("<Email")) {
-                let email = new Codenotch_1.ProjectManifestEmail();
-                email.name = fileName.replace(".auml", "");
-                email.file = StringUtils_1.default.toRelativePath(filePath, projectPath);
-                manifest.emails.push(email);
-            }
-            else if (trimmedAuml.startsWith("<HTML")) {
-                let html = new Codenotch_1.ProjectManifestHtml();
-                html.name = fileName.replace(".auml", "");
-                html.file = StringUtils_1.default.toRelativePath(filePath, projectPath);
-                manifest.htmls.push(html);
-            }
-        }
-        catch (e) {
-            console.error("Cannot save auml", filePath, e);
-        }
+    /**
+     * Find all file (recursivly) in a given folder (workspacePath) that contains a table declaration ('process').
+     */
+    static async discoverProcessFiles(workspacePath) {
     }
 }
-exports.default = ProjectCompilationUtils;
 //# sourceMappingURL=ProjectCompilationUtils.js.map