@simitgroup/simpleapp-generator 1.0.32 → 1.0.35

package/dist/generate.d.ts

@@ -0,0 +1,2 @@
+export declare const run: (paraconfigs: any, genFor: string[], callback: Function) => Promise<void>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AAiCA,eAAO,MAAM,GAAG,gBAAuB,GAAG,UAAQ,MAAM,EAAE,YAAU,QAAQ,kBAqE3E,CAAA"}

package/dist/generate.js

@@ -22,10 +22,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.initialize = void 0;
-// import { readFormBuilder } from './processors/formbuilder.tsa';
-// import { readJsonSchemaBuilder } from './processors/jsonschemabuilder';
+exports.run = void 0;
 const constants = __importStar(require("./constant"));
 const jsonschemabuilder_1 = require("./processors/jsonschemabuilder");
 const storage_1 = require("./storage");
@@ -34,254 +35,333 @@ const log = new tslog_1.Logger();
 const clc = require("cli-color");
 const path = require('path');
 const fs_1 = require("fs");
+const lodash_1 = __importDefault(require("lodash"));
+const buildinschemas = __importStar(require("./buildinschemas"));
 const { Eta } = require('eta');
 const { capitalizeFirstLetter } = require('./libs');
+const X_DOCUMENT_TYPE = 'x-document-type';
+const X_DOCUMENT_NAME = 'x-document-name';
+const X_COLLECTION_NAME = 'x-collection-name';
+const X_PAGE_TYPE = 'x-page-type';
 const extFb = '.xfb.json';
 const extHfb = '.xhfb.json';
 const extjsonschema = '.jsonschema.json';
+const extgroups = '.group.json';
 let jsonschemas = {};
+let configs = {};
 const docs = [];
-const initialize = async (defFolder, backendfolder, frontendfolder, callback) => {
-    prepareEnvironments(backendfolder, frontendfolder);
-    let activatemodules = [];
+let frontendFolder = '';
+let backendFolder = '';
+let frontendpagefolder = '';
+const allroles = {};
+let activatemodules = [];
+let generateTypes = {};
+const run = async (paraconfigs, genFor, callback) => {
+    configs = paraconfigs;
+    frontendFolder = configs.frontendFolder;
+    backendFolder = configs.backendFolder;
+    const groupFolder = configs.groupFolder;
+    if (genFor.includes('nest')) {
+        generateTypes['nest'] = backendFolder;
+    }
+    if (genFor.includes('nuxt')) {
+        generateTypes['nuxt'] = frontendFolder;
+    }
+    // console.log("genForgenForgenForgenFor",genFor,generateTypes)
     // 
-    const files = (0, fs_1.readdirSync)(defFolder);
-    // log.warn("all schemas:",files)
-    // readdir(defFolder, (err, files) => {
-    // files.forEach((file) => {
+    frontendpagefolder = `${frontendFolder}/pages/[xorg]`;
+    const buildinschemanames = Object.keys(buildinschemas);
+    for (let i = 0; i < buildinschemanames.length; i++) {
+        const schemaname = buildinschemanames[i];
+        // .forEach(async(schemaname)=>{    
+        const cloneschema = Object.assign({}, buildinschemas[schemaname]);
+        // console.log("=====>>>>>",schemaname,cloneschema)
+        await processSchema(schemaname, cloneschema);
+    }
+    // console.log('jsonschemasjsonschemasjsonschemasjsonschemas',jsonschemas)
+    // const buildinschemas = readdirSync(constants.buildinschemafolder)
+    // for(let i = 0; i< buildinschemas.length;i++){
+    //   const file = buildinschemas[i]
+    //   await processSchema(file,constants.buildinschemafolder)
+    // }
+    // load available bpmn into array
+    // const files = readdirSync(configs.jsonschemaFolder)
+    // for(let i = 0; i< files.length;i++){
+    //   const file = files[i]
+    //   await processSchema(file,constants.buildinschemafolder)
+    // }
+    // const schemapath = process.cwd()+'/'+ configs.jsonschemaFolder 
+    // console.log("dynamic import" ,schemapath)
+    // const {category} = require(schemapath)
+    // const schemas = await import('/Users/kstan/dev/products/simtrain-next/project-design/jsonschemas');
+    // console.log(schemas)
+    // const schemanames = Object.keys(schemas)
+    // for(let i=0; i<schemanames.length;i++){
+    //   const schemaname = schemanames[i]
+    // .forEach(async(schemaname)=>{    
+    // const cloneschema:JSONSchema7  = {...buildinschemas[schemaname]}
+    // console.log("=====>>>>>",schemaname,cloneschema)
+    // await processSchema(schemaname,cloneschema)
+    // }
+    //   
+    const files = (0, fs_1.readdirSync)(configs.jsonschemaFolder);
     for (let j = 0; j < files.length; j++) {
         const file = files[j];
-        log.info(`Load ` + clc.green(file));
-        const filearr = file.split('.');
-        let rendertype = 'basic';
-        const docname = filearr[0].toLowerCase();
-        const doctype = filearr[1].toLowerCase();
-        const jsonstring = (0, fs_1.readFileSync)(defFolder + path.sep + file, 'utf-8');
-        let allmodels = {};
-        if (file.endsWith(extjsonschema)) {
-            const jsondata = JSON.parse(jsonstring);
-            rendertype = 'basic';
-            jsonschemas[docname] = jsondata;
-            // foreignkeys:
-            // tmpforeignkeys:TypeForeignKey
-            allmodels = await (0, jsonschemabuilder_1.readJsonSchemaBuilder)(doctype, docname, jsondata, storage_1.foreignkeys);
-            //foreignkeycatalogues
-            // foreignkeys
-            generate(docname, doctype, rendertype, allmodels, backendfolder, frontendfolder);
-            activatemodules.push({ doctype: doctype, docname: capitalizeFirstLetter(docname) });
-        }
-        else {
-            log.warn(`Load ` + clc.yellow(file) + ` but it is not supported`);
-        }
+        const jsoncontent = (0, fs_1.readFileSync)(`${configs.jsonschemaFolder}/${file}`, 'utf-8');
+        const jsonschema = JSON.parse(jsoncontent);
+        await processSchema(file, jsonschema);
     }
-    // log.warn("foreignkeys---",foreignkeys)
-    log.info("Activated backend modules: ", JSON.stringify(activatemodules));
-    // log.info(activatemodules)
-    finalize(activatemodules, backendfolder, frontendfolder);
+    // //generate groups
+    // const systemgroups = readdirSync(`${groupFolder}`)
+    // for(let g = 0; g< systemgroups.length;g++){
+    //   const groupfile = systemgroups[g]
+    //   const groupjsonstr = readFileSync(`${groupFolder}/${groupfile}`, 'utf-8');      
+    //   const groupdata = JSON.parse(groupjsonstr);
+    //   const documentname = groupfile.split('.')[0]
+    //   const roles = prepareRoles(groupdata)
+    //   allroles[documentname]=roles
+    // }
+    finalize(activatemodules);
     callback();
 };
-exports.initialize = initialize;
-const generate = (docname, doctype, rendertype, allmodels, backendfolder, frontendfolder) => {
-    const targetfolder = `${backendfolder}/src/docs/${doctype}`;
-    const frontendpagefolder = `${frontendfolder}/pages/[xorg]`;
-    try {
-        (0, fs_1.mkdirSync)(targetfolder, { recursive: true });
-        (0, fs_1.mkdirSync)(`${frontendfolder}/simpleapp/simpleappdocs/`, { recursive: true });
-        (0, fs_1.mkdirSync)(frontendpagefolder, { recursive: true });
-    }
-    catch (err) {
-        //do nothing if folder exists
-    }
-    finally {
-        const templatefolder = `${constants.templatedir}/${rendertype}`;
-        log.info(`- Generate ${docname}, ${doctype}, ${templatefolder}`);
-        const eta = new Eta({
-            views: templatefolder,
-            functionHeader: 'const capitalizeFirstLetter = (str) => str.slice(0, 1).toUpperCase() + str.slice(1);' +
-                'const initType=(str)=>{return ["string","number","boolean","array","object"].includes(str) ? capitalizeFirstLetter(str) : str;}',
-        });
-        const variables = {
-            name: docname,
-            doctype: doctype,
-            models: allmodels,
-            autocompletecode: allmodels[capitalizeFirstLetter(docname)].codeField,
-            autocompletename: allmodels[capitalizeFirstLetter(docname)].nameField,
-            moreAutoComplete: allmodels[capitalizeFirstLetter(docname)].moreAutoComplete,
-            schema: allmodels[capitalizeFirstLetter(docname)].model,
-            apiSchemaName: capitalizeFirstLetter(docname),
-            typename: capitalizeFirstLetter(docname),
-            fullApiSchemaName: doctype + 'apischema.' + capitalizeFirstLetter(docname),
-            fullTypeName: doctype + 'type.' + capitalizeFirstLetter(docname),
-            jsonschema: jsonschemas[docname],
-            bothEndCode: '',
-            frontEndCode: '',
-            backEndCode: '',
-            controllerCode: '',
-            apiSchemaCode: '',
-            docStatusSettings: allmodels[capitalizeFirstLetter(docname)].docStatusSettings,
-            apiSettings: allmodels[capitalizeFirstLetter(docname)].apiSettings,
-            requireautocomplete: allmodels[capitalizeFirstLetter(docname)].requireautocomplete,
-            isolationtype: allmodels[capitalizeFirstLetter(docname)].isolationtype
-        };
-        // console.log('generate 2', JSON.stringify(variables));
-        // // const txtUISchema = eta.render('./uischema', variables);
-        // console.log('generate 4');
-        // console.log('generate 2', variables);
-        const txtType = eta.render('./type', variables);
-        (0, fs_1.writeFileSync)(`${targetfolder}/${doctype}.type.ts`, txtType);
-        // compile(jsonschemas[docname], docname).then((txtType: string) => {
-        //   writeFileSync(`${targetfolder}/${doctype}.type.ts`, txtType);
-        // });
-        // generate jsonschema object, use for data validation
-        const txtJsonSchema = eta.render('./jsonschema', variables);
-        (0, fs_1.writeFileSync)(`${targetfolder}/${doctype}.jsonschema.ts`, txtJsonSchema);
-        // generate before save source code, wont override after regenerate
-        // const customizefilename = `${targetfolder}/${doctype}.beforesave.ts`;
-        // if (!existsSync(customizefilename)) {
-        //   const txtBeforeSave = eta.render('./beforesave', variables);
-        //   writeFileSync(
-        //     `${targetfolder}/${doctype}.beforesave.ts`,
-        //     txtBeforeSave,
-        //   );
-        // }
-        // write mongoose model file
-        const txtModel = eta.render('./model', variables);
-        (0, fs_1.writeFileSync)(`${targetfolder}/${doctype}.model.ts`, txtModel);
-        // prepare openapi schema
-        const apischemafile = `${targetfolder}/${doctype}.apischema.ts`;
-        if ((0, fs_1.existsSync)(apischemafile)) {
-            const apischemaCode = (0, fs_1.readFileSync)(apischemafile).toString();
-            const regexapischema = /\/\/<begin-apischema-code>([\s\S]*?)\/\/<end-apischema-code>/g;
-            const apischemaresult = apischemaCode.match(regexapischema);
-            if (apischemaresult) {
-                variables.apiSchemaCode = apischemaresult[0];
-            }
-            else {
-                variables.apiSchemaCode = "//<begin-apischema-code>\n//<end-apischema-code>";
-            }
-        }
-        const txtApiSchema = eta.render('./apischema', variables);
-        (0, fs_1.writeFileSync)(apischemafile, txtApiSchema);
-        // prepare backend classes
-        // prepare frontend api client
-        const servicefile = `${targetfolder}/${doctype}.service.ts`;
-        let bothEndCode = '';
-        let backEndCode = '';
-        if ((0, fs_1.existsSync)(servicefile)) {
-            const servicecodes = (0, fs_1.readFileSync)(servicefile).toString();
-            /* extract string bothend and backend, put in back */
-            const regex1 = /\/\/<begin-bothend-code>([\s\S]*?)\/\/<end-bothend-code>/g;
-            const regex2 = /\/\/<begin-backend-code>([\s\S]*?)\/\/<end-backend-code>/g;
-            const bothendresult = servicecodes.match(regex1);
-            const backendresult = servicecodes.match(regex2);
-            console.log("bothendresult", bothendresult);
-            console.log("backendresult", backendresult);
-            if (bothendresult) {
-                variables.bothEndCode = bothendresult[0];
-            }
-            else {
-                variables.bothEndCode = "//<begin-bothend-code>\n//<end-bothend-code>";
+exports.run = run;
+// const processSchema=async (file:string,defFolder:string)=>{
+const processSchema = async (schemaname, jsondata) => {
+    var _a;
+    // console.log(file,defFolder)
+    // const filearr = file.split('.');
+    // let rendertype = 'basic';
+    // let docname = filearr[0].toLowerCase();
+    // let doctype = filearr[1].toLowerCase();
+    const config = jsondata['x-simpleapp-config'];
+    let doctype = config.documentType;
+    let docname = config.documentName;
+    // const jsonstring = readFileSync(defFolder +path.sep+ file, 'utf-8');      
+    // if (file.endsWith('.ts')) {  
+    //   log.info(`Load `+clc.green(file))
+    //   const filepath =  `${defFolder}/${file.replace('.ts','')}`
+    //   console.log(filepath)
+    //   const jsondata = require(filepath)
+    //   console.log(jsondata)
+    // const jsondata = JSON.parse(jsonstring);    
+    const rendertype = 'basic';
+    jsonschemas[docname] = jsondata;
+    const allmodels = await (0, jsonschemabuilder_1.readJsonSchemaBuilder)(docname, jsondata);
+    console.log("allmodels", docname, allmodels);
+    generateSchema(docname, doctype, rendertype, allmodels);
+    activatemodules.push({
+        doctype: doctype,
+        docname: capitalizeFirstLetter(docname),
+        pagetype: (_a = config.pageType) !== null && _a !== void 0 ? _a : '',
+        api: config.additionalApis
+    });
+    // } else {
+    // log.warn(`Load `+clc.yellow(file) + ` but it is not supported`)
+    // }      
+};
+/**
+ * generate frontend nuxt and backend nest codes.
+ *
+*/
+const generateSchema = (docname, doctype, rendertype, allmodels) => {
+    var _a, _b, _c, _d, _e, _f;
+    const simpleapptemplates = `${constants.templatedir}/basic`;
+    const finalizefolder = `${constants.templatedir}/nest`;
+    const modelname = lodash_1.default.upperFirst(docname);
+    const currentmodel = allmodels[modelname];
+    //console.log("---^^^^^------",modelname,docname, doctype, rendertype,currentmodel,allmodels)
+    const variables = {
+        name: docname,
+        doctype: doctype,
+        models: allmodels,
+        autocompletecode: (_a = currentmodel.codeField) !== null && _a !== void 0 ? _a : '',
+        autocompletename: (_b = currentmodel.nameField) !== null && _b !== void 0 ? _b : '',
+        moreAutoComplete: (_c = currentmodel.moreAutoComplete) !== null && _c !== void 0 ? _c : [],
+        schema: currentmodel.model,
+        apiSchemaName: capitalizeFirstLetter(docname),
+        typename: capitalizeFirstLetter(docname),
+        fullApiSchemaName: doctype + 'apischema.' + capitalizeFirstLetter(docname),
+        fullTypeName: doctype + 'type.' + capitalizeFirstLetter(docname),
+        jsonschema: jsonschemas[docname],
+        bothEndCode: '',
+        frontEndCode: '',
+        backEndCode: '',
+        controllerCode: '',
+        apiSchemaCode: '',
+        docStatusSettings: (_d = currentmodel.docStatusSettings) !== null && _d !== void 0 ? _d : [],
+        apiSettings: (_e = currentmodel.apiSettings) !== null && _e !== void 0 ? _e : [],
+        isolationtype: currentmodel.isolationtype,
+        hasdocformat: currentmodel.hasdocformat,
+        foreignkeys: (_f = currentmodel.foreignkeys) !== null && _f !== void 0 ? _f : {}
+    };
+    const templatefolder = `${constants.templatedir}/${rendertype}`;
+    log.info(`- Generate ${docname}, ${doctype}, ${templatefolder}`);
+    const eta = new Eta({
+        views: '/',
+        functionHeader: 'const capitalizeFirstLetter = (str) => str.slice(0, 1).toUpperCase() + str.slice(1);' +
+            'const initType=(str)=>{return ["string","number","boolean","array","object"].includes(str) ? capitalizeFirstLetter(str) : str;}',
+    });
+    const backendTargetFolder = `${backendFolder}/src/simpleapp/generate`;
+    const backendServiceFolder = `${backendFolder}/src/simpleapp/services`;
+    Object.keys(generateTypes).forEach((foldertype) => {
+        //generate code for every schema      
+        const generateTemplatefolder = `${constants.templatedir}/basic/${foldertype}`;
+        const allfiles = (0, fs_1.readdirSync)(generateTemplatefolder, { recursive: true });
+        for (let j = 0; j < allfiles.length; j++) {
+            const filename = String(allfiles[j]);
+            const templatepath = `${generateTemplatefolder}/${filename}`;
+            if (lodash_1.default.last(filename.split('.')) != 'eta') {
+                log.warn("skip file: ", filename);
+                continue;
             }
-            if (backendresult) {
-                variables.backEndCode = backendresult[0];
+            if (foldertype == 'nest') {
+                const arrfilename = filename.split('.');
+                const filecategory = arrfilename[0];
+                const filetype = arrfilename[1];
+                const autogeneratetypes = ['apischema', 'controller', 'jsonschema', 'model', 'processor', 'type', 'default'];
+                if (autogeneratetypes.includes(filecategory)) {
+                    //multiple files in folder, append s at folder name
+                    const storein = `${backendTargetFolder}/${filecategory}s`;
+                    const targetfile = `${storein}/${doctype}.${filecategory}.${filetype}`;
+                    if (!(0, fs_1.existsSync)(storein)) {
+                        (0, fs_1.mkdirSync)(storein, { recursive: true });
+                    }
+                    const filecontent = eta.render(templatepath, variables);
+                    (0, fs_1.writeFileSync)(targetfile, filecontent);
+                }
+                else if (filecategory == 'service') { //service file won't override if exists
+                    const targetfile = `${backendServiceFolder}/${doctype}.${filecategory}.${filetype}`;
+                    if (!(0, fs_1.existsSync)(backendServiceFolder)) {
+                        (0, fs_1.mkdirSync)(backendServiceFolder, { recursive: true });
+                    }
+                    if (!(0, fs_1.existsSync)(targetfile)) {
+                        const filecontent = eta.render(templatepath, variables);
+                        (0, fs_1.writeFileSync)(targetfile, filecontent);
+                    }
+                }
             }
-            else {
-                variables.backEndCode = "//<begin-backend-code>\n//<end-backend-code>";
+            else if (foldertype == 'nuxt') {
+                const capname = capitalizeFirstLetter(docname);
+                const validateWritePage = (folder, isexists) => {
+                    if (!jsonschemas[docname][X_PAGE_TYPE]) {
+                        return false;
+                    }
+                    else if (!isexists) {
+                        return true;
+                    }
+                    else if ((0, fs_1.existsSync)(`${folder}/delete-me.txt`)) {
+                        return true;
+                    }
+                    else {
+                        return false;
+                    }
+                };
+                const mapfiles = {
+                    'pages.[id].vue.eta': {
+                        to: `pages/[xorg]/${docname}`,
+                        as: '[id].vue',
+                        validate: validateWritePage
+                    },
+                    'pages.crud.vue.eta': {
+                        to: `pages/[xorg]/${docname}`,
+                        as: 'index.vue',
+                        validate: validateWritePage
+                    },
+                    'simpleapp.doc.ts.eta': {
+                        to: `simpleapp/docs`,
+                        as: `${capname}Doc.ts`,
+                        validate: (folder, isexists) => !isexists
+                    },
+                    'default.ts.eta': {
+                        to: `simpleapp/generate/defaults`,
+                        as: `${capname}.default.ts`,
+                        validate: (folder, isexists) => {
+                            return true;
+                        }
+                    },
+                    'simpleapp.generate.client.ts.eta': {
+                        to: `simpleapp/generate/clients`,
+                        as: `${capname}Client.ts`,
+                        validate: (folder, isexists) => {
+                            return true;
+                        }
+                    },
+                };
+                const target = mapfiles[filename];
+                const targetfolder = `${generateTypes[foldertype]}/${target.to}`;
+                const targetfile = `${targetfolder}/${target.as}`;
+                const isexists = (0, fs_1.existsSync)(targetfile);
+                const iswrite = target.validate(targetfolder, isexists);
+                log.warn("process: ", filename, '---->', targetfile);
+                if (iswrite && !(0, fs_1.existsSync)(targetfolder)) {
+                    (0, fs_1.mkdirSync)(targetfolder, { recursive: true });
+                    (0, fs_1.writeFileSync)(`${targetfolder}/delete-me.txt`, "delete this file for keep modified page");
+                }
+                // if(
+                //   target.override=="always" ||  
+                //     !existsSync(targetfile) || 
+                //     (target.override=="check"  && existsSync(`${targetfolder}/delete-me.txt`))
+                //     ){
+                if (iswrite) {
+                    const filecontent = eta.render(templatepath, variables);
+                    (0, fs_1.writeFileSync)(targetfile, filecontent);
+                }
             }
         }
-        const txtService = eta.render('./service', variables);
-        (0, fs_1.writeFileSync)(`${targetfolder}/${doctype}.service.ts`, txtService);
-        // prepare api router, allow add more api and wont override after regenerate
-        const controllerfile = `${targetfolder}/${doctype}.controller.ts`;
-        let controllerCode = '';
-        if ((0, fs_1.existsSync)(controllerfile)) {
-            /* extract customized controller, put in back */
-            const controllersourcecodes = (0, fs_1.readFileSync)(controllerfile).toString();
-            const controllerregex = /\/\/<begin-controller-code>([\s\S]*?)\/\/<end-controller-code>/g;
-            const controllerresult = controllersourcecodes.match(controllerregex);
-            if (controllerresult) {
-                controllerCode = controllerresult[0];
+    });
+};
+const finalize = (modules) => {
+    const renderProperties = {
+        configs: configs,
+        modules: modules,
+        allroles: allroles,
+        foreignkeys: storage_1.allforeignkeys,
+    };
+    Object.getOwnPropertyNames(generateTypes).forEach((foldertype) => {
+        const frameworkpath = generateTypes[foldertype];
+        log.info("Generate ", foldertype);
+        const frameworkfolder = `${constants.templatedir}/${foldertype}`;
+        const frameworkfiles = (0, fs_1.readdirSync)(frameworkfolder, { recursive: true });
+        const eta = new Eta({ views: frameworkfolder });
+        //generate code for framework
+        for (let index = 0; index < frameworkfiles.length; index++) {
+            const longfilename = String(frameworkfiles[index]);
+            const patharr = longfilename.split('/');
+            const filename = lodash_1.default.last(patharr);
+            const arrfilename = filename.split('.');
+            // log.info("check longfilename:::",longfilename,"become====",arrfilename)
+            //only process .eta
+            if (lodash_1.default.last(arrfilename) == 'eta') {
+                const relativepath = longfilename.includes('/') ? longfilename.replace(`/${filename}`, '') : '';
+                const foldername = `${frameworkpath}/${relativepath}`;
+                const shortfilename = filename.replace('.eta', '');
+                const targetfilename = `${foldername}/${shortfilename}`;
+                if (!(0, fs_1.existsSync)(foldername)) {
+                    (0, fs_1.mkdirSync)(foldername, { recursive: true });
+                }
+                const templatename = `${frameworkfolder}/${longfilename}`.replace(".eta", "");
+                log.info("Write template:", templatename, '----> ', targetfilename);
+                const txt = eta.render(longfilename, renderProperties);
+                (0, fs_1.writeFileSync)(targetfilename, txt);
             }
-        }
-        variables.controllerCode = controllerCode != '' ? controllerCode : "\n//<begin-controller-code>\n//<end-controller-code>";
-        const txtController = eta.render('./controller', variables);
-        (0, fs_1.writeFileSync)(controllerfile, txtController);
-        // prepare module
-        const txtModule = eta.render('./module', variables);
-        (0, fs_1.writeFileSync)(`${targetfolder}/${doctype}.module.ts`, txtModule);
-        // prepare readme
-        // const txtReadme = eta.render('./readme', variables);
-        // writeFileSync(`${targetfolder}/README.md`, txtReadme);
-        const frontendfile = `${frontendfolder}/simpleapp/simpleappdocs/${variables.typename}Doc.ts`;
-        let frontEndCode = '';
-        if ((0, fs_1.existsSync)(frontendfile)) {
-            const clientcodes = (0, fs_1.readFileSync)(frontendfile).toString();
-            /* extract string frontend code, put in back */
-            const regex3 = /\/\/<begin-frontend-code>([\s\S]*?)\/\/<end-frontend-code>/g;
-            const frontendresult = clientcodes.match(regex3);
-            if (frontendresult) {
-                frontEndCode = frontendresult[0];
+            else {
+                log.warn("skip: ", longfilename);
             }
         }
-        variables.frontEndCode = frontEndCode !== null && frontEndCode !== void 0 ? frontEndCode : '';
-        const txtDocClient = eta.render('./simpleappclient.eta', variables);
-        (0, fs_1.writeFileSync)(frontendfile, txtDocClient);
-        generateClientPage(variables, eta, frontendpagefolder);
-        log.info(`- write completed: ${doctype}`);
-    }
+    });
 };
-const generateClientPage = (variables, eta, frontendpagefolder) => {
-    const docname = variables.name;
-    const targetfolder = `${frontendpagefolder}/${docname}`;
-    const overridefilename = `${targetfolder}/delete-me-for-avoid-override`;
-    if (!(0, fs_1.existsSync)(targetfolder)) {
-        (0, fs_1.mkdirSync)(targetfolder);
-        (0, fs_1.writeFileSync)(overridefilename, 'delete this file to prevent override by generator');
-    }
-    if ((0, fs_1.existsSync)(overridefilename)) {
-        const txtIndex = eta.render('./pageindex.vue.eta', variables);
-        const txtIndexwithid = eta.render('./pageindexwithid.vue.eta', variables);
-        (0, fs_1.writeFileSync)(`${targetfolder}/index.vue`, txtIndex);
-        (0, fs_1.writeFileSync)(`${targetfolder}/[id].vue`, txtIndexwithid);
-    }
-};
-const prepareEnvironments = (backendfolder, frontendfolder) => {
-    const targetfolder = `${backendfolder}/src/class`;
-    const targetfrontendfolder = `${frontendfolder}/server/api`;
-    try {
-        (0, fs_1.mkdirSync)(targetfolder, { recursive: true });
-        (0, fs_1.mkdirSync)(targetfrontendfolder, { recursive: true });
-    }
-    catch (error) {
-        //do nothing
+const prepareRoles = (groupsettings) => {
+    let roles = [];
+    const docnames = Object.getOwnPropertyNames(groupsettings);
+    for (let i = 0; i < docnames.length; i++) {
+        let docname = docnames[i];
+        let docpermissions = groupsettings[docname];
+        for (let j = 0; j < docpermissions.length; j++) {
+            const perm = docpermissions[j];
+            const typename = lodash_1.default.upperFirst(docname);
+            roles.push(`${typename}_${perm}`);
+        }
     }
-    (0, fs_1.copyFileSync)(`${constants.templatedir}/nest/SimpleAppService.eta`, `${targetfolder}/SimpleAppService.ts`);
-    (0, fs_1.copyFileSync)(`${constants.templatedir}/nest/SimpleAppController.eta`, `${targetfolder}/SimpleAppController.ts`);
-    (0, fs_1.copyFileSync)(`${constants.templatedir}/nest/Workflow.eta`, `${targetfolder}/Workflow.ts`);
-    (0, fs_1.copyFileSync)(`${constants.templatedir}/nest/TenantMiddleware.eta`, `${targetfolder}/TenantMiddleware.ts`);
-    (0, fs_1.copyFileSync)(`${constants.templatedir}/nest/UserProvider.eta`, `${targetfolder}/UserProvider.ts`);
-    //copy over frontend apiabstract class
-    // copyFileSync(`${constants.templatedir}/nuxt.apigateway.eta`,`${targetfrontendfolder}/[...].ts`)
-    //prepare backend config.ts
-    //copy over frontend config.ts
-};
-const finalize = (modules, backendfolder, frontendfolder) => {
-    log.info("Finalizing foreignkey:", JSON.stringify(storage_1.foreignkeys));
-    (0, fs_1.mkdirSync)(`${backendfolder}/src/dicts/`, { recursive: true });
-    (0, fs_1.mkdirSync)(`${frontendfolder}/composables/`, { recursive: true });
-    const eta = new Eta({ views: constants.templatedir });
-    const txtMainModule = eta.render('./nest/app.module.eta', modules);
-    (0, fs_1.writeFileSync)(`${backendfolder}/src/app.module.ts`, txtMainModule);
-    const txtMainService = eta.render('./nest/app.service.eta', modules);
-    (0, fs_1.writeFileSync)(`${backendfolder}/src/app.service.ts`, txtMainService);
-    const txtAppController = eta.render('./nest/app.controller.eta', modules);
-    (0, fs_1.writeFileSync)(`${backendfolder}/src/app.controller.ts`, txtAppController);
-    const foreignkeyfile = `${backendfolder}/src/dicts/foreignkeys.json`;
-    (0, fs_1.writeFileSync)(foreignkeyfile, JSON.stringify(storage_1.foreignkeys));
-    log.info("write to foreignkey file ", foreignkeyfile);
-    const txtCatalogue = eta.render('./nuxt/composables.getautocomplete.ts.eta', modules);
-    (0, fs_1.writeFileSync)(`${frontendfolder}/composables/getAutocomplete.ts`, txtCatalogue);
-    const txtMenus = eta.render('./nuxt/composables.getmenus.ts.eta', modules);
-    (0, fs_1.writeFileSync)(`${frontendfolder}/composables/getMenus.ts`, txtMenus);
+    return roles;
 };
 //# sourceMappingURL=generate.js.map