@simitgroup/simpleapp-generator 1.0.32 → 1.0.35

package/src/generate.ts.backup

@@ -0,0 +1,339 @@
+import * as constants from './constant'
+import {readJsonSchemaBuilder} from './processors/jsonschemabuilder'
+import {foreignkeys} from './storage'
+import {TypeGenerateDocumentVariable,ChildModels,ModuleObject } 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'
+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 = [];
+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
+  }
+  
+  // 
+  frontendpagefolder = `${frontendFolder}/pages/[xorg]`  
+  Object.keys(buildinschemas).forEach(schemaname=>{
+    await processSchema(schemaname,buildinschemas[schemaname])
+  })
+
+  // 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 j = 0; j< files.length;j++){
+  //   const file = files[j]
+  //   await processSchema(file,configs.jsonschemaFolder)    
+  // }
+  // //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 processSchema=async (file:string,defFolder:string)=>{
+const processSchema=async (docname:string,jsondata:any)=>{
+  
+    // console.log(file,defFolder)
+    // const filearr = file.split('.');
+    // let rendertype = 'basic';
+    // let docname = filearr[0].toLowerCase();
+    // let doctype = filearr[1].toLowerCase();
+  
+    // const jsonstring = readFileSync(defFolder +path.sep+ file, 'utf-8');      
+    let allmodels: ChildModels = {} as ChildModels;
+    
+    // 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);    
+      // rendertype = 'basic';
+      jsonschemas[docname] = jsondata;
+      allmodels = await readJsonSchemaBuilder(doctype, docname, jsondata,foreignkeys);
+      // generateSchema(docname, doctype, rendertype, allmodels);        
+      // activatemodules.push({
+      //   doctype:doctype,
+      //   docname:capitalizeFirstLetter(docname),
+      //   pagetype: jsonschemas[docname][X_PAGE_TYPE]??'',
+      //   api:jsondata['x-document-api']
+      // })
+    // } else {
+      // log.warn(`Load `+clc.yellow(file) + ` but it is not supported`)
+    // }      
+}
+  
+/**
+ * generate frontend nuxt and backend nest codes.
+ * 
+*/
+const generateSchema = async( docname: string,
+  doctype: string,
+  rendertype: string,
+  allmodels: ChildModels)=>{
+    const simpleapptemplates = `${constants.templatedir}/basic`
+    const finalizefolder = `${constants.templatedir}/nest`
+    const currentmodel = allmodels[capitalizeFirstLetter(docname)]
+    const variables:TypeGenerateDocumentVariable = {
+      name: docname,
+      doctype: doctype,
+      models: allmodels,
+      autocompletecode:currentmodel.codeField,
+      autocompletename:currentmodel.nameField,
+      moreAutoComplete:currentmodel.moreAutoComplete,
+      schema: currentmodel.model,
+      apiSchemaName: capitalizeFirstLetter(docname), //capitalizeFirstLetter(doctype) + 'ApiSchema',
+      typename: capitalizeFirstLetter(docname),
+      fullApiSchemaName:
+        doctype + 'apischema.' + capitalizeFirstLetter(docname),
+      fullTypeName: doctype + 'type.' + capitalizeFirstLetter(docname),
+      jsonschema: jsonschemas[docname],
+      bothEndCode: '',
+      frontEndCode: '',
+      backEndCode: '',
+      controllerCode:'',
+      apiSchemaCode:'',
+      docStatusSettings: currentmodel.docStatusSettings,
+      apiSettings: currentmodel.apiSettings,
+      requireautocomplete: currentmodel.requireautocomplete,
+      isolationtype: currentmodel.isolationtype,      
+      hasdocformat: currentmodel.hasdocformat,
+      foreignkeys: currentmodel.foreignkeys
+    };
+
+    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.getOwnPropertyNames(generateTypes).forEach((foldertype)=>{
+      
+
+      //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);
+            }
+            
+            
+            
+
+        }
+      }
+      
+
+    })
+    
+   
+
+}
+
+
+const finalize=(modules:ModuleObject[])=>{  
+  const renderProperties = {
+    configs:configs,
+    modules:modules,
+    allroles:allroles,
+    foreignkeys:foreignkeys,
+  }
+  
+  
+  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 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
+}

package/src/index.ts

@@ -22,14 +22,23 @@ let version=pj.version
 program
   .version(version)
   .description("An simpleapp CLI tool for generate frontend (vuejs) and backend(nestjs) codes")  
-  .option("-c, --config-file <value>", 'configuration file content such as:{"definationsFolder":"./definations", "backendFolder":"./nestproject/src/docs", "frontendFolder":"./nuxt/server"}')
+  .option("-c, --config-file <value>", 'configuration file')
+  .option("-g, --generate-type <value>", 'generate type all, backend, frontend')
   .parse(process.argv);
 
 let path=''
 const options = program.opts();
 console.log(figlet.textSync(`SimpleApp Generator`));
 console.log(figlet.textSync(`${version}`));
-if(!options.configFile){
+let continueexecute = true
+if(options.generateType && options.generateType=='init'){
+  continueexecute=false
+  fw.prepareProject(()=>{
+    process.exit(1)
+  })  
+  
+}
+else if(!options.configFile){
     log.error("Config file parameter is required. Example: simpleapp-generator -c ./config.json")
     throw "Undefine configuration file"
   }
@@ -42,28 +51,94 @@ if(!options.configFile){
     log.error("undefine configuration file, use command simpleapp-generator -c <configfilename.json>")  
     throw error
   }
-  const configs = require(path)
-  console.log("configurations: ",configs)
-  const definationsFolder = configs.definationsFolder
-  const backendFolder = configs.backendFolder 
-  const frontendFolder = configs.frontendFolder 
-  const openapi3Yaml = configs.openapi3Yaml
 
-const run = async()=>{
+if(continueexecute){
+    
+    const configs = require(path)
+    // console.log("configurations: ",configs)
+    const jsonschemaFolder = configs.jsonschemaFolder
+    const bpmnFolder = configs.bpmnFolder
+    const backendFolder = configs.backendFolder 
+    const frontendFolder = configs.frontendFolder   
+
+
+
+  const run = async()=>{
+      fw.setConfiguration(configs)
+      fw.runCreateNuxt(()=>{
+          fw.runCreateNest(()=>{
+              fw.prepareNest(()=>{
+                  fw.prepareNuxt(()=>{
+                      // generate.initialize(jsonschemaFolder,configs.groupFolder,bpmnFolder,backendFolder,frontendFolder,()=>{                        
+                        generate.run(configs,['nest','nuxt'],()=>{
+                          fw.prettyNuxt()    
+                          fw.prettyNest()                                                
+                      })                    
+                  })                
+              })            
+          })
+      })
+  }
+  const reGenFrontend = async()=>{
+    fw.setConfiguration(configs)
+    generate.run(configs,['nuxt'],()=>{
+      fw.prettyNuxt()                                      
+    })  
+  }
+  const reGenBackend = async()=>{
+    fw.setConfiguration(configs)
+    generate.run(configs,['nest'],()=>{
+      fw.prettyNest()                                                
+    })  
+  }
+
+  const runbackend = async()=>{
+    fw.setConfiguration(configs)
     fw.setConfiguration(configs)
-    fw.runCreateNuxt(()=>{
         fw.runCreateNest(()=>{
             fw.prepareNest(()=>{
+                    // generate.run(jsonschemaFolder,configs.groupFolder,bpmnFolder,backendFolder,frontendFolder,()=>{
+                      generate.run(configs,['nest'],()=>{
+                        fw.prettyNest()                                                
+                    })                    
+          })                
+        
+      })
+  }
+
+  const runfrontend = async()=>{
+    fw.setConfiguration(configs)
+    fw.runCreateNuxt(()=>{
                 fw.prepareNuxt(()=>{
-                    generate.initialize(definationsFolder,backendFolder,frontendFolder,()=>{
-                        fw.prepareOpenApiClient()
+                    // generate.initialize(jsonschemaFolder,configs.groupFolder,bpmnFolder,backendFolder,frontendFolder,()=>{
+                    generate.run(configs,['nuxt'],()=>{
                         fw.prettyNuxt()    
-                        fw.prettyNest()                                                
                     })                    
-                })                
-            })            
         })
-     })
-}
+    })
+  }
+
+
+  switch(options.generateType){  
+    case 'updatefrontend':
+      reGenFrontend()
+    break;
+    case 'updatebackend':
+      reGenBackend()
+    break;
+    case 'frontend':
+      runfrontend()
+    break;
+    case 'backend':
+      runbackend()
+    break;
+    case 'all':
+      run()
+    break;
+    default:
+      log.error("unknown generate type")
+    break;
+
+  }
 
-run()
+}