bpm-core 0.0.129 → 0.0.130

package/cli/generate/new/copy-and-generate.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ejs_1 = __importDefault(require("ejs"));
+const prettier_1 = require("prettier");
+const util_1 = require("util");
+const utilities_1 = require("../../utilities/utilities");
+const renderEjsFile = (0, util_1.promisify)(ejs_1.default.renderFile);
+const sourceDir = path.join(__dirname, 'angular-template');
+const destDir = process.cwd();
+;
+function formatWithPrettier(content, fileName) {
+    const splitFileName = fileName.split('.');
+    const fileExtension = splitFileName[splitFileName.length - 1];
+    const parserTyp = {
+        'html': 'html',
+        'ts': 'typescript',
+        'css': 'css',
+        'scss': 'scss'
+    };
+    if (!parserTyp[fileExtension])
+        return Promise.resolve(content);
+    return (0, prettier_1.format)(content, { parser: parserTyp[fileExtension], printWidth: 120 });
+}
+async function processTemplateFiles(src, dest, serviceData) {
+    if (!fs.existsSync(dest))
+        fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src);
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry);
+        const stats = fs.statSync(srcPath);
+        if (stats.isDirectory()) {
+            if (entry === '@@comp-template@@') {
+                const srcPathForPageComponents = src;
+                const destPathForPageComponents = dest;
+                await writePageComponents(srcPathForPageComponents, destPathForPageComponents, serviceData);
+                continue;
+            }
+            const subDest = path.join(dest, entry);
+            await processTemplateFiles(srcPath, subDest, serviceData);
+        }
+        else if (stats.isFile()) {
+            const isEjs = entry.endsWith('.ejs');
+            const outputFilename = isEjs ? entry.slice(0, -4) : entry;
+            const destPath = path.join(dest, outputFilename);
+            if (isEjs) {
+                const result = await renderEjsFile(srcPath, serviceData);
+                if (result && result.trim()) {
+                    const formattedResult = await formatWithPrettier(result, destPath);
+                    fs.writeFileSync(destPath, formattedResult, 'utf8');
+                }
+            }
+            else {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+}
+async function writePageComponents(src, dest, serviceData) {
+    if (!fs.existsSync(dest))
+        fs.mkdirSync(dest, { recursive: true });
+    const templateWrapperPath = path.join(src, '@@comp-template@@');
+    const entries = fs.readdirSync(templateWrapperPath);
+    for (const compInfo of serviceData.getPageComponents()) {
+        for (const entry of entries) {
+            if (entry.startsWith('_'))
+                continue;
+            const filePath = path.join(templateWrapperPath, entry);
+            let result = await renderEjsFile(filePath, compInfo);
+            const fileSuffix = entry.match(/@@(?<suffix>.+).ejs/)?.groups?.suffix;
+            const fileName = compInfo.componentNameKebab + fileSuffix;
+            const dir = path.join(dest, compInfo.componentNameKebab);
+            const destPath = path.join(dir, fileName);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            if (fileSuffix.endsWith('.ts')) {
+                result = compInfo.importsManager.renderImports(result);
+            }
+            const formattedResult = await formatWithPrettier(result, fileName);
+            fs.writeFileSync(destPath, formattedResult, 'utf8');
+        }
+    }
+}
+async function main(serviceData) {
+    const logger = new utilities_1.Logger();
+    try {
+        await logger.asyncLog('Generating the service...')(processTemplateFiles(sourceDir, destDir, serviceData), `${serviceData.serviceCode} Service Generated.`, 'Service Generation Failed.');
+    }
+    catch (err) {
+        console.log(`${err.message} ${(err.cause?.message || err.cause) ? 'because ' + (err.cause?.message || err.cause) : ''}`);
+    }
+}

package/cli/generate/new/field.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+;

package/cli/generate/new/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNewProjectCommand = void 0;
+const commander_1 = require("commander");
+const copy_and_generate_1 = require("./copy-and-generate");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const service_data_1 = require("./service-data");
+exports.generateNewProjectCommand = new commander_1.Command('new');
+exports.generateNewProjectCommand.description('Generate a new project based on the provided config, like the form builder');
+exports.generateNewProjectCommand.alias('n');
+exports.generateNewProjectCommand.requiredOption('--config <string>', 'Path to config file');
+exports.generateNewProjectCommand.requiredOption('--service-code <string>', 'Service Code');
+exports.generateNewProjectCommand.action((options) => {
+    const cwd = process.cwd();
+    const configPath = path.join(cwd, options.config);
+    const serviceCode = options.serviceCode;
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    const configContent = fs.readFileSync(configPath, 'utf-8');
+    const config = JSON.parse(configContent);
+    (0, copy_and_generate_1.main)(new service_data_1.ServiceData(serviceCode, config));
+});

package/cli/generate/new/service-data.js

@@ -0,0 +1,284 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceData = void 0;
+const changeCase = __importStar(require("change-case"));
+class ServiceData {
+    constructor(serviceCode, stages) {
+        this.serviceCode = serviceCode;
+        this.stages = stages;
+        this.visibilityCodeLOVEnums = this.parseLOVEnums();
+        this.changeCase = changeCase;
+        this.en = {};
+        this.ar = {};
+        this.addI18n();
+    }
+    getPageComponents() {
+        return Object.entries(this.stages).map(([key, value]) => {
+            return {
+                componentNameKebab: `${changeCase.kebabCase(key)}-section`,
+                componentNamePascal: `${changeCase.pascalCase(key)}Section`,
+                fields: value.fields,
+                getCommonAttributes(field) {
+                    const attrs = {
+                        class: "section-item",
+                        formControlName: field.fieldName,
+                        "[label]": `'${changeCase.camelCase(field.label)}' | translate`,
+                        "[mandatory]": field.required,
+                        "[isReadOnly]": field.readOnly ? 'true' : 'section?.header?.readOnly',
+                    };
+                    return Object.entries(attrs).map(([key, value]) => `${key}="${value}"`).join('\n');
+                },
+                importsManager: new ImportsManager(),
+                getFieldType(field) {
+                    const importManager = this.importsManager;
+                    switch (field.componentName) {
+                        case 'input':
+                            importManager.addImport('InputComponent', 'bpm-core', true);
+                            return 'string';
+                        case 'textarea':
+                            importManager.addImport('TextareaComponent', 'bpm-core', true);
+                            return 'string';
+                        case 'input-currency':
+                            importManager.addImport('InputCurrencyComponent', 'bpm-core', true);
+                            return 'string';
+                        case 'input-number':
+                            importManager.addImport('InputNumberComponent', 'bpm-core', true);
+                            return 'string';
+                        case 'datepicker':
+                            importManager.addImport('DatePickerComponent', 'bpm-core', true);
+                            return 'string';
+                        case 'select':
+                            importManager.addImport('CustomSearchableComponent', 'bpm-core', true);
+                            importManager.addImport('Select', 'bpm-core');
+                            return 'Select';
+                        case 'search-employee':
+                            importManager.addImport('SearchEmployeeComponent', 'bpm-core', true);
+                            importManager.addImport('Employee', 'bpm-core');
+                            return 'Employee';
+                        case 'attachment-section':
+                            importManager.addImport('AttachmentSectionComponent', 'bpm-core', true);
+                            importManager.addImport('Attachment', 'bpm-core');
+                            return 'Attachment[]';
+                        case 'file-uploader':
+                            importManager.addImport('DocsUploaderComponent', 'bpm-core', true);
+                            importManager.addImport('Attachment', 'bpm-core');
+                            return 'Attachment';
+                        case 'table':
+                            return 'any[]';
+                        default:
+                            return 'any';
+                    }
+                },
+                changeCase: changeCase,
+                getValidators(field) {
+                    const importManager = this.importsManager;
+                    const validators = [];
+                    switch (field.componentName) {
+                        case 'input':
+                            if (field.required)
+                                validators.push('Validators.required');
+                            if (field.minLength)
+                                validators.push(`Validators.minLength(${field.minLength})`);
+                            break;
+                        case 'textarea':
+                            if (field.required)
+                                validators.push('Validators.required');
+                            if (field.minLength)
+                                validators.push(`Validators.minLength(${field.minLength})`);
+                            break;
+                        case 'select':
+                            importManager.addImport('DataValidators', 'bpm-core');
+                            if (field.required)
+                                validators.push('DataValidators.selectRequired');
+                            break;
+                        case 'search-employee':
+                            importManager.addImport('DataValidators', 'bpm-core');
+                            if (field.required)
+                                validators.push('DataValidators.employeeRequired');
+                            break;
+                        case 'file-uploader':
+                            importManager.addImport('DataValidators', 'bpm-core');
+                            if (field.required) {
+                                if (field.multiple)
+                                    validators.push('DataValidators.multiFileUploaderRequired');
+                                else
+                                    validators.push('DataValidators.fileUploaderRequired');
+                            }
+                            break;
+                        case 'attachment-section':
+                            importManager.addImport('DataValidators', 'bpm-core');
+                            if (field.required)
+                                validators.push('DataValidators.multiFileUploaderRequired');
+                            break;
+                        default:
+                            if (field.required)
+                                validators.push('Validators.required');
+                    }
+                    let output = `[${validators.join(',')}]`;
+                    if ('visibilityCheckCode' in field && field.componentName !== 'hint') {
+                        importManager.addImport('validateOnlyWhen', 'bpm-core');
+                        output = `validateOnlyWhen(() => this.${changeCase.camelCase(`is ${field.fieldName} visible`)}, [${validators.join(',')}])`;
+                    }
+                    return output;
+                },
+                getEnumName(field) {
+                    const code = field.visibilityCheckCode;
+                    return [...code.matchAll(/(?<![\w?.])(?<enumName>\b\w+Enum)\.(?<key>\w+)\b/g)]
+                        .map(item => item.groups.enumName);
+                }
+            };
+        });
+    }
+    addI18n() {
+        const requestStage = this.stages.requestDetails;
+        const setI18n = (field) => {
+            if (field.label) {
+                const labelKey = changeCase.camelCase(field.label);
+                this.en[labelKey] = field.labelEn;
+                this.ar[labelKey] = field.labelAr;
+            }
+            if (field.componentName === 'panel-start' || field.componentName === 'hint') {
+                const labelKey = changeCase.camelCase(field.headerName);
+                this.en[labelKey] = field.headerNameEn;
+                this.ar[labelKey] = field.headerNameAr;
+            }
+            if (field.componentName === 'table') {
+                field.tableColumns.forEach(col => setI18n(col));
+            }
+        };
+        if (requestStage) {
+            this.en.formTitle = requestStage.labelEn;
+            this.ar.formTitle = requestStage.labelAr;
+            requestStage.fields.forEach(field => setI18n(field));
+        }
+        this.getRoleStages().forEach(stageInfo => {
+            const stageTitleKey = `${stageInfo.role.toLowerCase()}Role`;
+            this.en[stageTitleKey] = stageInfo.titleEn;
+            this.ar[stageTitleKey] = stageInfo.titleAr;
+            stageInfo.fields.forEach(field => setI18n(field));
+        });
+    }
+    getRoleStages() {
+        const roleStages = [];
+        Object.entries(this.stages)
+            .filter(([key, value]) => key !== 'requestDetails')
+            .forEach(([key, item]) => {
+            item.roles.forEach((role, index) => {
+                roleStages.push({
+                    role: role.toLowerCase(),
+                    compClass: `${changeCase.pascalCase(key)}SectionComponent`,
+                    dirName: `${changeCase.kebabCase(key)}-section`,
+                    fbConfigKey: key,
+                    printPartialName: changeCase.camelCase(`section ${key}`),
+                    fields: item.fields,
+                    titleAr: item.rolesAr[index],
+                    titleEn: item.rolesEn[index]
+                });
+            });
+        });
+        return roleStages;
+    }
+    getSegmentDynamicLoaderConfig() {
+        const roleStages = this.getRoleStages();
+        const compClassToDirName = roleStages.reduce((prev, curr) => {
+            prev[curr.compClass] = curr.dirName;
+            return prev;
+        }, {});
+        return {
+            roleToCompClass: roleStages.map(item => `${item.role}: ${item.compClass}`).join(',\n'),
+            imports: Object.entries(compClassToDirName).map(([compClass, compDirName]) => `import { ${compClass} } from '../page-components/${compDirName}/${compDirName}.component';`).join('\n')
+        };
+    }
+    getPrintPartials() {
+        let output;
+        output = Object.entries(this.stages).map(([key, value]) => {
+            return {
+                printPartialName: changeCase.camelCase(`section ${key}`),
+                fields: value.fields
+            };
+        });
+        return output;
+    }
+    checkInAllFieldsStages(checker) {
+        return Object.values(this.stages).some(stage => stage.fields.some(field => {
+            return checker(field);
+        }));
+    }
+    parseLOVEnums() {
+        const lovEnums = {};
+        Object.entries(this.stages).forEach(([key, value]) => {
+            value.fields.forEach(field => {
+                const visibilityCheckCode = field.visibilityCheckCode;
+                if (visibilityCheckCode) {
+                    [...visibilityCheckCode.matchAll(/(?<![\w?.])(?<enumName>\b\w+Enum)\.(?<key>\w+)\b/g)]
+                        .forEach(match => {
+                        const { enumName, key } = match.groups;
+                        if (!lovEnums[enumName]) {
+                            lovEnums[enumName] = new Set();
+                        }
+                        lovEnums[enumName].add(key);
+                    });
+                }
+            });
+        });
+        if (!Object.keys(lovEnums).length)
+            return null;
+        return lovEnums;
+    }
+}
+exports.ServiceData = ServiceData;
+class ImportsManager {
+    constructor() {
+        this.imports = {};
+        this.componentImports = new Set();
+    }
+    addImport(value, path, addToComponentImports = false) {
+        if (!this.imports[path]) {
+            this.imports[path] = new Set();
+        }
+        if (!Array.isArray(value))
+            value = [value];
+        value.forEach(item => this.imports[path].add(item));
+        if (addToComponentImports) {
+            value.forEach(item => this.componentImports.add(item));
+        }
+    }
+    getImports() {
+        return Object.entries(this.imports).map(([path, value]) => `import { ${[...value].join(', ')} } from '${path}';`).join('\n');
+    }
+    getComponentImports() {
+        return [...this.componentImports].join(', ');
+    }
+    renderImports(tsContent) {
+        if (this.componentImports.size) {
+            tsContent = tsContent.replace(/imports:\s*\[\]/, `imports: [${this.getComponentImports()}]`);
+        }
+        if (Object.keys(this.imports).length) {
+            tsContent = `${this.getImports()}\n${tsContent}`;
+        }
+        return tsContent;
+    }
+}