@simitgroup/simpleapp-generator 1.0.32 → 1.0.35

package/src/generate.ts

@@ -1,104 +1,168 @@
-// import { readFormBuilder } from './processors/formbuilder.tsa';
-// import { readJsonSchemaBuilder } from './processors/jsonschemabuilder';
 import * as constants from './constant'
 import {readJsonSchemaBuilder} from './processors/jsonschemabuilder'
-import {foreignkeys} from './storage'
-// import { compile } from 'json-schema-to-typescript';
-// import { Fieldtypes, SchemaModel, ChildModels } from './type';
-import { TypeForeignKeyCatalogue,  TypeGenerateDocumentVariable,ChildModels,ModuleObject } from './type'
+import {allforeignkeys} from './storage'
+import {TypeGenerateDocumentVariable,ChildModels,ModuleObject, SchemaType, SchemaConfig } from './type'
 import { Logger, ILogObj } from "tslog";
 const log: Logger<ILogObj> = new Logger();
 const clc = require("cli-color");
-
-
 const path = require('path');
 import {mkdirSync, readdir,readFileSync,writeFileSync,existsSync,copyFileSync, readdirSync} from 'fs'
+import _ from 'lodash'
+import * as buildinschemas from './buildinschemas'
+import { JSONSchema7 } from 'json-schema';
 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:any = {}
 const docs = [];
-
-export const initialize =  async (defFolder:string,backendfolder:string,frontendfolder:string,callback:Function) => {
-  prepareEnvironments(backendfolder,frontendfolder)
-  let activatemodules:ModuleObject[]=[]
+let frontendFolder=''
+let backendFolder=''
+let frontendpagefolder=''
+const allroles:any={}
+let activatemodules:ModuleObject[]=[]
+let generateTypes:any = {}
+
+
+export const run =  async (paraconfigs:any,genFor:string[],callback:Function) => {
+  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 = readdirSync(defFolder)
-  // log.warn("all schemas:",files)
-  // readdir(defFolder, (err, files) => {
-    // files.forEach((file) => {
-    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 = readFileSync(defFolder +path.sep+ file, 'utf-8');      
-      let allmodels: ChildModels = {} as ChildModels;
-      
-      if (file.endsWith(extjsonschema)) {  
-        const jsondata = JSON.parse(jsonstring);      
-        rendertype = 'basic';
-        jsonschemas[docname] = jsondata;
-        // foreignkeys:
-        // tmpforeignkeys:TypeForeignKey
-        allmodels = await readJsonSchemaBuilder(doctype, docname, jsondata,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`)
-      }      
-    }
-    // log.warn("foreignkeys---",foreignkeys)
-    log.info("Activated backend modules: ",JSON.stringify(activatemodules))
-    // log.info(activatemodules)
-    finalize(activatemodules,backendfolder,frontendfolder)
-    callback()
+  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:JSONSchema7  = {...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 = readdirSync(configs.jsonschemaFolder)
+  for(let j = 0; j< files.length;j++){
+    const file = files[j]
+    const jsoncontent = readFileSync(`${configs.jsonschemaFolder}/${file}`, 'utf-8');      
+    const jsonschema = JSON.parse(jsoncontent)
+    await processSchema(file,jsonschema)    
+  }
+  // //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()
+}
 
-const generate = (
-  docname: string,
+// const processSchema=async (file:string,defFolder:string)=>{
+const processSchema= async (schemaname:string,jsondata:JSONSchema7)=>{
+  
+    // console.log(file,defFolder)
+    // const filearr = file.split('.');
+    // let rendertype = 'basic';
+    // let docname = filearr[0].toLowerCase();
+    // let doctype = filearr[1].toLowerCase();
+    const config:SchemaConfig = 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:ChildModels =  await readJsonSchemaBuilder(docname, jsondata);
+      console.log("allmodels",docname,allmodels)
+      generateSchema(docname, doctype, rendertype, allmodels);        
+      activatemodules.push({
+        doctype:doctype,
+        docname:capitalizeFirstLetter(docname),
+        pagetype: config.pageType??'',
+        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: string,
   doctype: string,
   rendertype: string,
-  allmodels: ChildModels,
-  backendfolder:string,
-  frontendfolder:string
-) => {
-  const targetfolder = `${backendfolder}/src/docs/${doctype}`;
-  const frontendpagefolder=`${frontendfolder}/pages/[xorg]`
-  try {
-    
-    mkdirSync(targetfolder,{ recursive: true });    
-    mkdirSync(`${frontendfolder}/simpleapp/simpleappdocs/`,{ recursive: true });
-    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;}',
-    });
+  allmodels: ChildModels)=>{
+
     
+    const simpleapptemplates = `${constants.templatedir}/basic`
+    const finalizefolder = `${constants.templatedir}/nest`
+    const modelname = _.upperFirst(docname)
+    const currentmodel = allmodels[modelname]
+
+    //console.log("---^^^^^------",modelname,docname, doctype, rendertype,currentmodel,allmodels)
     const variables:TypeGenerateDocumentVariable = {
       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,
+      autocompletecode:currentmodel.codeField??'',
+      autocompletename:currentmodel.nameField??'',
+      moreAutoComplete:currentmodel.moreAutoComplete ??[],
+      schema: currentmodel.model,
       apiSchemaName: capitalizeFirstLetter(docname), //capitalizeFirstLetter(doctype) + 'ApiSchema',
       typename: capitalizeFirstLetter(docname),
       fullApiSchemaName:
@@ -110,207 +174,204 @@ const generate = (
       backEndCode: '',
       controllerCode:'',
       apiSchemaCode:'',
-      docStatusSettings:allmodels[capitalizeFirstLetter(docname)].docStatusSettings,
-      apiSettings:allmodels[capitalizeFirstLetter(docname)].apiSettings,
-      requireautocomplete:allmodels[capitalizeFirstLetter(docname)].requireautocomplete,
-      isolationtype:allmodels[capitalizeFirstLetter(docname)].isolationtype
+      docStatusSettings: currentmodel.docStatusSettings??[],
+      apiSettings: currentmodel.apiSettings??[],
+      isolationtype: currentmodel.isolationtype,      
+      hasdocformat: currentmodel.hasdocformat,
+      foreignkeys: currentmodel.foreignkeys ?? {}
     };
 
-    // 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);
-    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);
-    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);
-    writeFileSync(`${targetfolder}/${doctype}.model.ts`, txtModel);
-
-    // prepare openapi schema
-    const apischemafile=`${targetfolder}/${doctype}.apischema.ts`
-    if (existsSync(apischemafile)) {
-      const apischemaCode = 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);
-    writeFileSync(apischemafile, txtApiSchema);
-
-    // prepare backend classes
-    // prepare frontend api client
-
-    const servicefile = `${targetfolder}/${doctype}.service.ts`;
-    let bothEndCode = '';
-    let backEndCode = '';
-    if (existsSync(servicefile)) {
-      const servicecodes = 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>";
-      }
-
-      if (backendresult) {
-        variables.backEndCode = backendresult[0];
-      }else{
-        variables.backEndCode="//<begin-backend-code>\n//<end-backend-code>";
-      }
-    }
-
- 
-    const txtService = eta.render('./service', variables);
-    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 (existsSync(controllerfile)) {
-      /* extract customized controller, put in back */
-      const controllersourcecodes = readFileSync(controllerfile).toString();        
-      const controllerregex = /\/\/<begin-controller-code>([\s\S]*?)\/\/<end-controller-code>/g;
-      const controllerresult = controllersourcecodes.match(controllerregex);
-      if (controllerresult) {
-        controllerCode = controllerresult[0];
-      }
-    }
-    variables.controllerCode = controllerCode!='' ? controllerCode : "\n//<begin-controller-code>\n//<end-controller-code>";
-    const txtController = eta.render('./controller', variables);
-    writeFileSync(controllerfile, txtController);
-
-    // prepare module
-    const txtModule = eta.render('./module', variables);
-    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 (existsSync(frontendfile)) {
-      const clientcodes = 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];
-      }
-    }
-    variables.frontEndCode = frontEndCode ?? '';
-    const txtDocClient = eta.render('./simpleappclient.eta', variables);
-    writeFileSync(frontendfile, txtDocClient);
-
-    generateClientPage(variables,eta,frontendpagefolder)
-
+    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;}',
+    });
     
-    log.info(`- write completed: ${doctype}`)
+    const backendTargetFolder = `${backendFolder}/src/simpleapp/generate`
+    const backendServiceFolder = `${backendFolder}/src/simpleapp/services`    
     
     
-  }
-};
-
-const generateClientPage=(variables:TypeGenerateDocumentVariable,eta,frontendpagefolder:string)=>{
-  const docname = variables.name
-  const targetfolder = `${frontendpagefolder}/${docname}`
-  const overridefilename = `${targetfolder}/delete-me-for-avoid-override`
-  if(!existsSync(targetfolder)){
-    mkdirSync(targetfolder)
-    writeFileSync(overridefilename,'delete this file to prevent override by generator')
-  }
-  if(existsSync(overridefilename)){
-    const txtIndex=  eta.render('./pageindex.vue.eta', variables);
-    const txtIndexwithid=  eta.render('./pageindexwithid.vue.eta', variables);
-    writeFileSync(`${targetfolder}/index.vue`,txtIndex)
-    writeFileSync(`${targetfolder}/[id].vue`,txtIndexwithid)
-  }
-}
-const prepareEnvironments = (backendfolder:string,frontendfolder:string)=>{
-  const targetfolder = `${backendfolder}/src/class`
-  const targetfrontendfolder = `${frontendfolder}/server/api`
-  try{
-    mkdirSync(targetfolder,{recursive:true});
-    mkdirSync(targetfrontendfolder,{recursive:true});
-  }catch(error){
-    //do nothing
-  }
-  
-  copyFileSync(`${constants.templatedir}/nest/SimpleAppService.eta`,`${targetfolder}/SimpleAppService.ts`)
-  copyFileSync(`${constants.templatedir}/nest/SimpleAppController.eta`,`${targetfolder}/SimpleAppController.ts`)
-  copyFileSync(`${constants.templatedir}/nest/Workflow.eta`,`${targetfolder}/Workflow.ts`)
-  copyFileSync(`${constants.templatedir}/nest/TenantMiddleware.eta`,`${targetfolder}/TenantMiddleware.ts`)
-  copyFileSync(`${constants.templatedir}/nest/UserProvider.eta`,`${targetfolder}/UserProvider.ts`)
+    Object.keys(generateTypes).forEach((foldertype)=>{
+      
 
-  //copy over frontend apiabstract class
-  // copyFileSync(`${constants.templatedir}/nuxt.apigateway.eta`,`${targetfrontendfolder}/[...].ts`)
+      //generate code for every schema      
+      const generateTemplatefolder = `${constants.templatedir}/basic/${foldertype}`    
+      const allfiles = readdirSync(generateTemplatefolder,{recursive:true})      
+      for(let j=0; j<allfiles.length;j++){
+        const filename:string = String(allfiles[j])      
+        const templatepath = `${generateTemplatefolder}/${filename}`        
+        
+        if(_.last(filename.split('.'))!='eta'){
+          log.warn("skip file: ",filename)
+          continue;
+        }
+        if(foldertype=='nest'){
+          const arrfilename:string[] = 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(!existsSync(storein)){
+              mkdirSync(storein,{recursive:true})
+            }                
+            const filecontent = eta.render(templatepath, variables)     
+            writeFileSync(targetfile,filecontent);
+          }else if(filecategory=='service'){ //service file won't override if exists
+
+            const targetfile = `${backendServiceFolder}/${doctype}.${filecategory}.${filetype}`
+            if(!existsSync(backendServiceFolder)){
+              mkdirSync(backendServiceFolder,{recursive:true})
+            }         
+            if(!existsSync(targetfile)){
+              const filecontent = eta.render(templatepath, variables)     
+              writeFileSync(targetfile,filecontent);
+            }
+            
+          }      
+        }else if(foldertype=='nuxt'){
+          const capname = capitalizeFirstLetter(docname)
+          const validateWritePage = (folder:string,isexists:boolean)=>{
+            if(!jsonschemas[docname][X_PAGE_TYPE] ){
+              return false
+            }else if(!isexists){
+              return true
+            }else if( 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:string,isexists:boolean)=>!isexists
+            },
+            'default.ts.eta': { 
+              to:`simpleapp/generate/defaults`, 
+              as:`${capname}.default.ts`,
+              validate: (folder:string,isexists:boolean)=>{
+                return true
+              }
+            },
+            
+            'simpleapp.generate.client.ts.eta': { 
+              to:`simpleapp/generate/clients`, 
+              as:`${capname}Client.ts`, 
+              validate: (folder:string,isexists:boolean)=>{
+                return true
+              }
+            },
+          }
+            
+            const target = mapfiles[filename]            
+            const targetfolder = `${generateTypes[foldertype]}/${target.to}`
+            const targetfile = `${targetfolder}/${target.as}`
+            const isexists = existsSync(targetfile)
+            const iswrite:boolean = target.validate(targetfolder,isexists)
+            log.warn("process: ",filename,'---->',targetfile)
+            if(iswrite && !existsSync(targetfolder)){
+              mkdirSync(targetfolder,{recursive:true})
+              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)     
+              writeFileSync(targetfile,filecontent);
+            }
+            
+            
+            
+
+        }
+      }
+      
 
-    //prepare backend config.ts
+    })
+    
+   
 
-  //copy over frontend config.ts
 }
 
 
-const finalize=(modules:ModuleObject[],backendfolder:string,frontendfolder:string)=>{
-  log.info("Finalizing foreignkey:",JSON.stringify(foreignkeys))
-  mkdirSync(`${backendfolder}/src/dicts/`,{ recursive: true });
-  mkdirSync(`${frontendfolder}/composables/`,{ recursive: true });
-
-  const eta = new Eta({views:constants.templatedir});
-  const txtMainModule = eta.render('./nest/app.module.eta', modules);
-  writeFileSync(`${backendfolder}/src/app.module.ts`, txtMainModule);
+const finalize=(modules:ModuleObject[])=>{  
+  const renderProperties = {
+    configs:configs,
+    modules:modules,
+    allroles:allroles,
+    foreignkeys:allforeignkeys,
+  }
   
-  const txtMainService = eta.render('./nest/app.service.eta', modules);
-  writeFileSync(`${backendfolder}/src/app.service.ts`, txtMainService);
-
-  const txtAppController = eta.render('./nest/app.controller.eta', modules);
-  writeFileSync(`${backendfolder}/src/app.controller.ts`, txtAppController);
-
-  const foreignkeyfile =`${backendfolder}/src/dicts/foreignkeys.json`
-  writeFileSync(foreignkeyfile, JSON.stringify(foreignkeys));
-  log.info("write to foreignkey file ",foreignkeyfile)
   
-  const txtCatalogue = eta.render('./nuxt/composables.getautocomplete.ts.eta', modules);
-  writeFileSync(`${frontendfolder}/composables/getAutocomplete.ts`, txtCatalogue);
+  Object.getOwnPropertyNames(generateTypes).forEach((foldertype)=>{
+      const frameworkpath = generateTypes[foldertype]
+      log.info("Generate ",foldertype)
+      const frameworkfolder = `${constants.templatedir}/${foldertype}`
+      const frameworkfiles = 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 = String(frameworkfiles[index])
+        const patharr = longfilename.split('/')
+        const filename = _.last(patharr)
+        const arrfilename:string[] = filename.split('.')
+        // log.info("check longfilename:::",longfilename,"become====",arrfilename)
+        //only process .eta
+        if(_.last(arrfilename)=='eta'){                    
+          const relativepath = longfilename.includes('/') ? longfilename.replace(`/${filename}`,'') : ''
+          const foldername = `${frameworkpath}/${relativepath}`
+          const shortfilename = filename.replace('.eta','')
+          const targetfilename = `${foldername}/${shortfilename}`
+          if(!existsSync(foldername)){
+            mkdirSync(foldername,{recursive:true})
+          }
+          const templatename = `${frameworkfolder}/${longfilename}`.replace(".eta","")
+          log.info("Write template:",templatename, '----> ',targetfilename)
+          const txt = eta.render(longfilename, renderProperties)
+          writeFileSync(targetfilename,txt)
+          
+        }else{
+          log.warn("skip: ",longfilename)
+        }
+        
+        }
+      })
 
-  const txtMenus = eta.render('./nuxt/composables.getmenus.ts.eta', modules);
-  writeFileSync(`${frontendfolder}/composables/getMenus.ts`, txtMenus);
-  
+}
+
+const prepareRoles =(groupsettings) => {
+  let roles = []
+  const docnames = Object.getOwnPropertyNames(groupsettings)
+  for(let i = 0; i< docnames.length; i++){
+    let docname = docnames[i]
+    let docpermissions:string[] = groupsettings[docname]
+    for(let j=0;j<docpermissions.length;j++){
+      const perm = docpermissions[j]
+      const typename = _.upperFirst(docname)
+      roles.push(`${typename}_${perm}`)
+    }
+  }
+  return roles
 }