@simitgroup/simpleapp-generator 1.0.32 → 1.0.35

package/src/processors/jsonschemabuilder.ts-old

@@ -0,0 +1,383 @@
+// import { ExceptionsHandler } from '@nestjs/core/exceptions/exceptions-handler';
+import { JSONSchema7, JSONSchema7Definition,JSONSchema7Array,JSONSchema7TypeName } from 'json-schema';
+import * as js7 from 'json-schema';
+import { capitalizeFirstLetter } from '../libs';
+import {JsonSchemaProperties,MyForeignKey} from "../type"
+import { Logger, ILogObj } from "tslog";
+import $RefParser from "@apidevtools/json-schema-ref-parser";
+import {foreignkeys} from '../storage'
+// import { ConflictException } from '@nestjs/common';
+import {
+  FieldModel,
+  Fieldtypes,
+  ChildModels,
+  SchemaModel,
+  TypeForeignKey,
+  TypeForeignKeyCatalogue,
+  DocSetting,ApiSetting,DocStatusSetting,
+  
+} from '../type';
+import { json } from 'stream/consumers';
+const log: Logger<ILogObj> = new Logger();
+
+const X_DOCUMENT_NO='x-document-no'
+const X_DOCUMENT_LABEL='x-document-label'
+const X_AUTOCOMPLETE_FIELD='x-autocomplete-field'
+const X_DOCUMENT_NAME='x-document-name'
+const X_DOCUMENT_TYPE='x-document-type'
+const X_COLLECTION_NAME='x-document-collection'
+const X_DOCUMENT_STATUS='x-document-status'
+const X_DOCUMENT_API='x-document-api'
+const X_IGNORE_AUTOCOMPLETE='x-ignore-autocomplete'
+const FOREIGNKEY_PROPERTY='x-foreignkey'
+
+const FORMAT_TEL='tel'
+const FORMAT_DOCNO='documentno'
+const X_ISOLATION_TYPE='x-isolation-type'
+
+let docSetting:DocSetting={} as DocSetting
+
+let hasdocformat = false
+let allmodels: ChildModels = {};
+let fullschema={}
+// let fieldAutoCompleteCode=''
+// let fieldAutoCompleteName=''
+let moreAutoComplete:string[]=[]
+
+
+const newDocSetting=(doctype:string,docname:string):DocSetting=>{
+  return {
+    docName:docname,  //done
+    docType:doctype,  //done
+    colDocNo:'',      //done
+    colDocLabel:'',   //done
+    collectionName:docname, //done
+    autocompleteFields:[],
+    docStatusSettings:[],
+    apiSettings:[],
+    requireautocomplete:true,
+    isolationtype:"org",    
+    foreignkeys:{}
+
+  }
+}
+export const readJsonSchemaBuilder = async (
+  doctype: string,
+  docname: string,
+  orijsondata:JSONSchema7,
+  allforeignkeys:TypeForeignKeyCatalogue
+) => {
+  docSetting=newDocSetting(doctype,docname)
+  hasdocformat=false
+  // fieldAutoCompleteCode=''
+  // fieldAutoCompleteName=''
+  moreAutoComplete=[]
+  allmodels = {};
+  
+  const validateddata: JSONSchema7 = { ...orijsondata };
+  let schema: SchemaModel | SchemaModel[];
+  const  tmpjsondata = await $RefParser.dereference(orijsondata).then((schema)=>{
+    // console.log("schema",doctype, schema['properties']['category']? schema['properties']['category']:'')
+    return schema
+  })
+  const  jsondata:JSONSchema7 = {...tmpjsondata} as JSONSchema7
+
+  
+  if (jsondata && jsondata.type == 'object') {
+    //no _id then need add
+    // console.log(jsondata)
+    schema = processObject(doctype,docname, jsondata)
+    // console.log("schema",schema)
+  } else if (jsondata.type == 'array') {
+    throw(`unsupport array type for ${docname}.${doctype}`)
+  }
+
+  if(docSetting.colDocNo=='' && docSetting.requireautocomplete) {
+    log.error(`you shall define 1 field with property:'${X_DOCUMENT_NO}'`)
+    throw "missing field property"
+  }
+  if(docSetting.colDocLabel=='' && docSetting.requireautocomplete) {
+    log.error(`you shall define 1 field with property: '${X_DOCUMENT_LABEL}'}`)
+    throw "missing field property"
+  }
+  
+  return Promise.resolve(allmodels);
+};
+
+
+const processObject =  (doctype: string,
+  docname: string,
+  jsondata:JSONSchema7,)  =>{
+    if(!jsondata['properties']){      
+      throw ("Invalid json schema {doctype}.{docname}, no 'properties' defined")
+    }
+    log.info("processObject document type",doctype,docname)
+    
+
+    //ensure some field exists, also override it
+    jsondata.properties['_id'] = {type: 'string',description: 'Control value, dont edit it',};
+    jsondata.properties['doctype'] = {type: 'string', default:doctype, examples: [doctype],description: 'Control value, dont edit it',};
+    jsondata.properties['created'] = {type: 'string',description: 'Control value, dont edit it',};
+    jsondata.properties['updated'] = {type: 'string',description: 'Control value, dont edit it',};
+    jsondata.properties['createdby'] = {type: 'string',description: 'Control value, dont edit it',};
+    jsondata.properties['updatedby'] = {type: 'string',description: 'Control value, dont edit it',};
+
+    if(doctype !='tenant'){
+      jsondata.properties['tenantId'] = {type: 'number',description: 'Control value, dont edit it',};
+    }
+    if(doctype !='org'){
+      jsondata.properties['orgId'] = {type: 'number',description: 'Control value, dont edit it',};
+    }
+    if(doctype !='branch'){
+      jsondata.properties['branchId'] = {type: 'number',description: 'Control value, dont edit it',};
+    }
+    
+    if(jsondata[X_ISOLATION_TYPE] && ['none','tenant','org','branch'].includes(jsondata[X_ISOLATION_TYPE])  ){      
+      docSetting.isolationtype=jsondata[X_ISOLATION_TYPE]
+    }
+    if(jsondata[X_IGNORE_AUTOCOMPLETE] && jsondata[X_IGNORE_AUTOCOMPLETE]==true){
+      docSetting.requireautocomplete=false
+    }
+    if(jsondata[X_DOCUMENT_API] && Array.isArray(jsondata[X_DOCUMENT_API])){
+      // log.warn("x-document-api exists:")
+      // log.warn(jsondata[X_DOCUMENT_API])
+      for(let i=0; i<jsondata[X_DOCUMENT_API].length;i++){
+        
+        const tmp:ApiSetting =jsondata[X_DOCUMENT_API][i]
+        // console.log(i,jsondata[X_DOCUMENT_API]['action'])
+        if(!tmp.action){
+          const errmsg = "x-document-api defined but undefine property 'action'"
+          log.error(errmsg)
+          
+          throw errmsg
+        }
+        if(!tmp.method){
+          const errmsg = "x-document-api defined but undefine property 'method'"
+          log.error(errmsg)
+          throw errmsg
+        }
+        
+        let isexists = false
+        for(let i =0; i< docSetting.apiSettings.length ; i++){
+          const apiobj = docSetting.apiSettings[i]
+          // log.info(docname," validate:tmp["+tmp['action']+"]==apiobj["+apiobj['action'] +"]&&tmp["+ tmp['method']+"] == apiobj["+apiobj['method']+"]")
+          if(tmp['action']==apiobj['action'] && tmp['method'] == apiobj['method']){
+            //skip
+            isexists=true
+            break;
+          }
+        }
+        if(!isexists){
+          docSetting.apiSettings.push(tmp)
+        }
+     }
+    }
+    // log.warn("docSetting.apiSettings",docSetting.apiSettings)
+      if(jsondata[X_DOCUMENT_STATUS] && Array.isArray(jsondata[X_DOCUMENT_STATUS])){
+        for(let i=0; i<jsondata[X_DOCUMENT_STATUS].length;i++){
+          const tmp:DocStatusSetting =jsondata[X_DOCUMENT_STATUS][i]
+          if(tmp.statusCode ===undefined){
+            const errmsg = "x-document-status defined but undefine property 'statusCode'"
+            log.error(errmsg)
+            throw errmsg
+          }
+          if(!tmp.statusName ===undefined){
+            const errmsg = "x-document-status defined but undefine property 'statusName'"
+            log.error(errmsg)
+            throw errmsg            
+          }
+          docSetting.docStatusSettings.push(tmp)
+        }
+     }
+
+    //  moreAutoComplete:docSetting.autocompleteFields,
+    // docStatusSettings:docSetting.docStatusSettings,
+    // apiSettings:docSetting.apiSettings,
+    // SchemaModel | SchemaModel[]
+    let data =  genSchema(
+      capitalizeFirstLetter(docname),
+      'object',
+      jsondata.properties,
+      jsondata['required'] ?? [],
+      '$'
+    );
+    
+    return data
+}
+
+const genSchema = (docname: string,schematype: string,jsondata: JsonSchemaProperties,
+  requiredlist: string[] | undefined,parentpath:string): SchemaModel => {
+  const newmodel: SchemaModel = {};
+  const props = Object.getOwnPropertyNames(jsondata ??{});
+  // console.log('==== jsondata', jsondata);
+  console.log("requiredlist:::::",docname,"::::",requiredlist)
+  for (let i = 0; i < props.length; i++) {    
+    const key = props[i];
+    
+    //below is Object.assign use for force datatype compatibility
+    const obj:JSONSchema7={}
+    Object.assign(obj,jsondata[key]);
+    const objectitem:JSONSchema7= {} as JSONSchema7    
+    Object.assign(objectitem,obj.items);
+
+    let isrequired = false
+    if(requiredlist &&  requiredlist.includes(key)){
+      isrequired=true
+    }
+    const newName: string = docname + capitalizeFirstLetter(key);
+    // log.info("property is:",key,newName,obj)
+   if(obj[X_DOCUMENT_NO]){    
+    docSetting.colDocNo=key
+    if(obj['format'] && obj['format']==FORMAT_DOCNO){
+      hasdocformat=true
+    }else{
+      hasdocformat=false
+      obj.minLength=obj.minLength??1
+      jsondata[key]['minLength']=obj.minLength  
+    }
+    
+   }
+   if(obj[X_DOCUMENT_LABEL]){
+    docSetting.colDocLabel=key
+    obj.minLength=obj.minLength??1
+    jsondata[key]['minLength']=obj.minLength
+   }
+
+   //this field reserved for X_DOCUMENT_NO only
+   
+  
+   
+  //  if(obj[X_COLLECTION_NAME]){
+  //   docSetting.collectionName=key    
+  //  }
+
+
+   if(obj[X_AUTOCOMPLETE_FIELD]){
+    docSetting.autocompleteFields.push(key)
+   }
+   
+
+  //  if(obj.format && obj.format==FORMAT_TEL){
+  //   obj.pattern=obj.pattern ?? '/^\d{7,15}$/gm'
+  //  }
+  //  if (obj.type == 'object' && obj.items  ){
+  //   console.log("Refer to another object",docname,': ',key,obj,obj.items)
+    
+    // obj,obj.items
+    //foreignkeys
+    //FOREIGNKEY_PROPERTY
+    // newmodel[key] = 'Object';
+    // }
+    // else 
+    if(obj[FOREIGNKEY_PROPERTY]){
+      // console.warn("FOREIGNKEY_PROPERTY exists",FOREIGNKEY_PROPERTY,obj[FOREIGNKEY_PROPERTY])
+      const masterdatacollection = obj[FOREIGNKEY_PROPERTY]
+      const clientdatacollection = docname.toLowerCase()
+      const foreignkeyidentity= key
+      const foreignkeypath = (obj.type=='object') ?`${parentpath}.${key}._id`:`${parentpath}.${key}`
+      
+      if(docSetting.foreignkeys[masterdatacollection]){
+        docSetting.foreignkeys[masterdatacollection].push(foreignkeypath)
+      }else{
+        docSetting.foreignkeys[masterdatacollection]=[foreignkeypath]
+      }
+      if(!foreignkeys[masterdatacollection]){
+        let tmp:TypeForeignKey = {} as TypeForeignKey
+        tmp[clientdatacollection]=[foreignkeyidentity]
+        foreignkeys[masterdatacollection] = tmp
+      }
+      else if(!foreignkeys[masterdatacollection][clientdatacollection]){
+        foreignkeys[masterdatacollection][clientdatacollection]=[foreignkeyidentity]
+      }else{
+        foreignkeys[masterdatacollection][clientdatacollection].push(foreignkeyidentity)
+      }
+              
+    }
+
+    if (obj.type == 'object') {
+            
+      genSchema(newName, obj.type, obj.properties, obj.required,`${parentpath}.${key}`);
+      newmodel[key] = newName;
+    } else if (obj.type == 'array' && obj.items && objectitem?.type == 'object') {
+      const childprops = objectitem?.properties
+      if(!childprops['created']){
+        childprops['created']={type:'string',description:'iso8601 dataempty mean new record'}
+      }
+      if(!childprops['updated']){
+        childprops['updated']={type:'string',description:'iso8601 or empty'}
+      }
+      if(!childprops['createdby']){
+        childprops['createdby']={type:'string'}
+      }
+      if(!childprops['updatedby']){
+        childprops['updatedby']={type:'string'}
+      }
+      if(!childprops['_id']){
+        childprops['_id']={type:'string'}
+      }
+
+      genSchema(newName, obj.type, objectitem?.properties, obj.items['required'],`${parentpath}.${key}[*]`);
+      newmodel[key] = [newName];
+    } else if (obj.type == 'array' && objectitem?.type != 'object') {
+      //array need submodel
+      // genSchema(newName, obj.type, obj.items.properties);
+      const objecttype:string = objectitem.type?.toString() ?? 'string'
+      newmodel[key] = [objecttype];
+    } else {
+      newmodel[key] = getField(key, obj, isrequired);
+      // console.log(key,'--------newmodel',obj, newmodel[key]);
+    }
+  }
+  allmodels[docname] = { 
+    type: schematype, 
+    model: newmodel,
+    codeField: docSetting.colDocNo ,
+    nameField: docSetting.colDocLabel,
+    moreAutoComplete:docSetting.autocompleteFields,
+    docStatusSettings:docSetting.docStatusSettings,
+    apiSettings:docSetting.apiSettings,
+    requireautocomplete:docSetting.requireautocomplete,
+    isolationtype:docSetting.isolationtype,
+    hasdocformat:hasdocformat,
+    foreignkeys: docSetting.foreignkeys
+  };
+  // console.warn("-------------apiSettings-----",docname,"::::",docSetting.apiSettings)
+  return newmodel;
+};
+
+const getField = (
+  fieldname: string,
+  obj: JSONSchema7,
+  isrequired: boolean | undefined,
+): FieldModel => {
+  let datatype: Fieldtypes = obj.type as Fieldtypes
+  // console.log(datatype)
+  //Fieldtypes.string;
+  let format = obj.format;
+  if (obj.type == 'integer') {
+    datatype = Fieldtypes.number;
+    format = 'integer';
+  }
+
+  const f: FieldModel = {
+    type: datatype,
+    // oritype: obj.type,
+    required: isrequired,
+  };
+
+  if (obj.title) f.title = obj.title;
+  if (obj.description) f.description = obj.description;
+  if (obj.format) f.format = obj.format;
+  if (obj.examples) f.examples = obj.examples;
+  if (obj.default) {
+    f.default = obj.default;
+  } else {
+    if (f.type == 'string') f.default = '';
+    else if (f.type == 'number' || f.type == 'integer') f.default = 0;
+    else if (f.type == 'boolean') f.default = false;
+    else if (f.type == 'array') f.default = [];
+    else f.default = {};
+  }
+  return f;
+};
+

package/src/storage.ts

@@ -1,3 +1,3 @@
 import { TypeForeignKeyCatalogue } from './type'
 
-export let foreignkeys:TypeForeignKeyCatalogue = {}
+export let allforeignkeys:TypeForeignKeyCatalogue = {}

package/src/type.ts

@@ -1,15 +1,18 @@
-import { JSONSchema7, JSONSchema7Definition } from 'json-schema';
+import { allforeignkeys } from './storage';
+import { JSONSchema7, JSONSchema7Definition,JSONSchema7Object } from 'json-schema';
 export type ChildModels = {
   [key: string]: { 
     type: string; 
     model: SchemaModel,
     codeField:string,
     nameField:string,
-    moreAutoComplete:string[],
-    docStatusSettings:DocStatusSetting[],
-    apiSettings:ApiSetting[],
-    requireautocomplete: boolean
+    moreAutoComplete?:string[],
+    docStatusSettings?:DocumentStatus[],
+    apiSettings?:DocumentApi[],
+    // requireautocomplete: boolean
     isolationtype:string
+    hasdocformat:boolean,
+    foreignkeys:MyForeignKey
   };
 };
 export enum Fieldtypes {
@@ -45,6 +48,13 @@ export type JsonSchemaProperties= {
   // JSONSchema7Definition ,JSONSchema7
 }
 
+//foreign key setting in current document
+export type MyForeignKey = {
+  [collectionname:string]:string[]
+}
+
+
+//centralize foreignkey catalogue for all document
 export type TypeForeignKeyCatalogue = {
   [cataloguename:string]:TypeForeignKey
 }
@@ -54,6 +64,8 @@ export type TypeForeignKey={
 export type ModuleObject = {
   doctype:string
   docname:string
+  pagetype:string
+  api:DocumentApi[]
 }
 export type TypeGenerateDocumentVariable ={
 name: string
@@ -73,28 +85,14 @@ frontEndCode: string
 backEndCode: string
 controllerCode:string
 apiSchemaCode:string
-docStatusSettings:DocStatusSetting[],
-apiSettings:ApiSetting[],
-requireautocomplete:boolean,
+docStatusSettings:DocumentStatus[],
+apiSettings:DocumentApi[],
 isolationtype:string
-}
+hasdocformat:boolean,
+foreignkeys: MyForeignKey
 
-export type DocStatusSetting = {
-  statusCode:string,
-  statusName:string,
-  allowApi:string[],
-  readonly?:boolean,
-  description?:''
 }
 
-export type ApiSetting = {
-  method:string,
-  action:string,  
-  setDocStatus?:'',
-  description?:'',
-  bpmnApi?:'',
-  data?:any
-}
 export type DocSetting = {
   docName:string,
   docType:string,
@@ -102,8 +100,77 @@ export type DocSetting = {
   colDocLabel:string,
   collectionName:string,
   autocompleteFields:string[],
-  docStatusSettings:DocStatusSetting[],
-  apiSettings:ApiSetting[],
-  requireautocomplete:boolean
+  docStatusSettings:DocumentStatus[],
+  apiSettings:DocumentApi[],
+  // requireautocomplete:boolean
   isolationtype:string
-}
+  foreignkeys: MyForeignKey
+}
+
+export type DocumentStatus = {
+  status:string  //'CO', 'V', 'CL', 'D' and etc
+  statusName:string
+  readOnly:boolean
+  actions: string[]    //api name ['confirm','revert','close','void' and etc]
+}
+export enum RESTMethods {'post'='post','get'='get', 'delete'='delete','put'='put', 'patch'='patch'}
+export type DocumentApi = {
+  action:string   //api action name
+  entrypoint:string   //api entry point example:':id', ':id/confirm'
+  querypara?:string[]   //what query parameter wish to accept, example:  ['description','date']
+  requiredrole?: string[]   // what special user role wish to allow for this api, example: ['SuperUser']
+  method:RESTMethods
+  execute:string,   //what service class method name to execute, example: 'ping','getDocumentName'
+  description:string //description of api
+}
+export enum IsolationType {"none"="none" , "tenant"="tenant","org"="org", "branch"="branch"}
+export type ImportLibs = {"lib":string,"as":string}
+export type Formula =  {
+  "jsonpath":string  //example: "$.subtotal","$.details[*]"
+  "formula":string  //example "jslib.getDocumentSubTotal(@F{$.details})"
+} 
+
+export type SchemaConfig = {
+  isolationType: IsolationType
+  requiredRoles?:string[]
+  pageType?: string  
+  uniqueKey?:string  
+  documentTitle?:string 
+  generateDocumentNumber?:boolean
+  documentDate?:string
+  allStatus?:DocumentStatus[]
+  additionalApis?:DocumentApi[]      
+  additionalAutoCompleteFields ?: string[]
+  libs?:ImportLibs[]   // both process class and frontend client class will import same lib
+  formulas?: Formula[]  
+  documentType: string
+  documentName: string
+  collectionName?: string
+  foreignKeys?:MyForeignKey,
+}
+
+// export type DefaultSchemaDefinitions = {
+//   [key:string]:JSONSchema7Object
+// }
+export type ForeignKeyProperty = {'x-foreignkey' ?:string}
+export type SchemaFields = {
+  _id: JSONSchema7 
+  tenantId: JSONSchema7 & ForeignKeyProperty
+  orgId: JSONSchema7 & ForeignKeyProperty
+  branchId: JSONSchema7 & ForeignKeyProperty
+  created: JSONSchema7 
+  updated: JSONSchema7 
+  createdby: JSONSchema7 
+  updatedby: JSONSchema7 
+  [key:string]:JSONSchema7  & ForeignKeyProperty
+}
+
+export type AdditionalSchemaType = {     
+  "x-simpleapp-config":SchemaConfig  
+  properties: SchemaFields
+} 
+
+export type SchemaType = JSONSchema7 & AdditionalSchemaType
+
+
+