@simitgroup/simpleapp-generator 1.0.32 → 1.0.35

package/templates/nest/src/simpleapp/generate/processors/simpleapp.processor.ts.eta

@@ -0,0 +1,624 @@
+import { Injectable, Logger,Inject } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import * as jsonpath from 'jsonpath'
+import {  uniq } from 'lodash';
+
+import {foreignkeys} from '../commons/dicts/foreignkeys'
+import { Model,Types,PipelineStage,mongo, FilterQuery, ProjectionType} from 'mongoose';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import addErrors from 'ajv-errors';
+import {
+  NotFoundException,
+  BadRequestException,
+  ForbiddenException,
+  InternalServerErrorException,
+  HttpExceptionOptions,
+} from '@nestjs/common/exceptions';
+import { UserContext } from '../commons/user.context';
+import { DocNumberFormatGenerator } from '../commons/docnogenerator.service';
+
+export enum IsolationType {
+  'none' = 'none',
+  'org' = 'org',
+  'tenant' = 'tenant',
+  'branch' = 'branch',
+}
+export enum HookType {
+  'init' = 'init',
+  'beforeSearch' = 'beforeSearch',
+  'afterSearch' = 'afterSearch',
+  'beforeValidation' = 'beforeValidation',
+  'afterValidation' = 'afterValidation',
+  'beforeCreate' = 'beforeCreate',
+  'afterCreate' = 'afterCreate',
+  'beforeUpdate' = 'beforeUpdate',
+  'afterUpdate' = 'afterUpdate',
+  'beforeDelete' = 'beforeDelete',
+  'afterDelete' = 'afterDelete',
+  'beforeFetchRecord' = 'beforeFetchRecord',
+  'afterFetchRecord' = 'afterFetchRecord',
+}
+export type MoreProjectionType = {
+  [key: string]: string;
+};
+@Injectable()
+export class SimpleAppService<T extends { _id?: string }> {
+  protected logger = new Logger();
+  protected strictIsolation = true
+  protected jsonschema = { type: 'object', properties: {}, required: [] };
+  protected documentIdentityCode = 'code';
+  protected documentIdentityLabel = 'label';
+  protected documentName = '-unknowndocname-';
+  protected documentType = '-unknowndoctype-';
+  protected LIMITPERPAGE = 20;
+  protected moreAutoCompleteField: MoreProjectionType = {};
+  protected isolationtype: IsolationType = IsolationType.org;
+  protected isolationFilter: any = {};
+  protected data: T = { _id: '' } as T;
+  protected doc: Model<T>; //set private to prevent developer break data isolation control
+  protected errorlist = [];
+  protected withDocNumberFormat=false
+  protected foreignkeys = {}
+  // protected userprovider = new UserContext() ;
+
+  constructor(
+    doctype: string,
+    docname: string,
+    newdoc: Model<T>,
+    isolationtype: IsolationType = IsolationType.org,
+    private docnogenerator:DocNumberFormatGenerator
+  ) {            
+    // console.log("-------init simpleapp service abstract class -------userprovider=",typeof this.userprovider)
+    this.documentType = doctype.toUpperCase();
+    this.documentName = docname;
+    this.doc = newdoc;
+    this.isolationtype = isolationtype;
+    this.hook(undefined,HookType.init, undefined);
+    // this.tenantdoc = tenantdoc
+  }
+  getDocumentType = () => this.documentType;
+  getDocumentName = () => this.documentName;
+  getRecordId = (): string => this.data._id;
+  setSchema = (newschema) => (this.jsonschema = newschema);
+  getSchema = () => this.doc.schema.obj;
+  getData = () => {
+    //console.log('thisdata', this.data);
+    return this.data;
+  };
+  setData = (newdata: T) => {
+    delete newdata._id;
+    this.data = { ...newdata };
+    return this;
+  };
+  reCalculate() {}
+  getIsolationFilter = (appuser:UserContext,) => {
+    let isolationFilter = {};
+    switch (this.isolationtype) {
+      case 'none':
+        isolationFilter = {};
+        break;
+      case 'branch':
+        isolationFilter = appuser.getBranchFilter();
+        break;
+      case 'tenant':
+        isolationFilter = appuser.getTenantFilter();
+        break;
+      case 'org':
+      default:
+        isolationFilter = appuser.getOrgFilter();
+        break;
+    }
+    return isolationFilter;
+  };
+  async list(appuser:UserContext,) {
+    try {
+      //console.log("this.isolationFilter",this.getIsolationFilter())
+      const products = await this.doc.find(this.getIsolationFilter(appuser));
+      // console.log(products)
+      const productlist = products.map((p: T) => {
+        return p;
+      });
+      //   console.log(products);
+      return productlist;
+    } catch (err) {
+      throw new InternalServerErrorException(err.message);
+    }
+  }
+  addAutoCompleteField = (morefield: MoreProjectionType) => {
+    const props = Object.getOwnPropertyNames(morefield);
+    // console.log('addAutoCompleteField', props);
+    for (let i = 0; i < props.length; i++) {
+      const key = props[i];
+      this.moreAutoCompleteField[key] = '$' + morefield[key];
+    }
+    // console.log(this.moreAutoCompleteField);
+  };
+  async getAutoComplete(appuser:UserContext, keyword: string) {
+    try {
+      const filter1 = {};
+      const filter2 = {};
+      let filters: any[] = [];
+      if (
+        this.jsonschema.properties[this.documentIdentityCode]['type'] ==
+        'string'
+      ) {
+        filter1[this.documentIdentityCode] = { $regex: keyword, $options: 'i' };
+        filters.push(filter1);
+      }
+
+      filter2[this.documentIdentityLabel] = { $regex: keyword, $options: 'i' };
+      filters.push(filter2);
+      const filterobj = { $or: filters };
+
+      Object.assign(filterobj, this.getIsolationFilter(appuser));
+      let projections = {
+        id: `\$_id`,
+        label: `\$${this.documentIdentityLabel}`,
+        code: `\$${this.documentIdentityCode}`,
+      };
+      if (this.moreAutoCompleteField) {
+        Object.assign(projections, this.moreAutoCompleteField);
+      }
+      const products = await this.doc.find(filterobj, projections, {
+        limit: this.LIMITPERPAGE,
+      });
+      const productlist = products.map((p: T) => {
+        return p;
+      });
+      return productlist;
+    } catch (err) {
+      throw new InternalServerErrorException(err.message);
+    }
+  }
+
+  /**
+   * Special search function which can by pass data isolation. reserved and try not use
+   * @param appuser 
+   * @param filters 
+   * @returns 
+   */
+  private async searchNoIsolation(appuser:UserContext,filters: Object) {
+    try {
+      await this.hook(appuser,HookType.beforeSearch, filters);
+      const products = await this.doc.find(filters);
+      const productlist = products.map((p: T) => {
+        return p;
+      });
+      await this.hook(appuser,HookType.afterSearch, productlist);
+      //   console.log(products);
+      return productlist;
+    } catch (err) {
+      throw new InternalServerErrorException(err.message);
+    }
+    // return this;
+  }
+  async aggregate(appuser:UserContext,pipeline:PipelineStage[]){
+    
+    if(pipeline[0] && pipeline[0]['$match']){      
+      try{
+        const isolationFilter= {... this.getIsolationFilter(appuser)}
+        this.polishIsolationFilter(isolationFilter)      
+       
+
+        Object.assign(pipeline[0]['$match'],isolationFilter);
+        console.log("final agg",pipeline)
+        return await this.doc.aggregate(pipeline)
+      }catch(err){
+        throw new InternalServerErrorException(err);  
+      }
+      
+    }else{
+      throw new InternalServerErrorException('first aggregate pipelinestage shall use $match');
+    }
+
+  }
+  async search(appuser:UserContext,filters: FilterQuery<T>,projection:ProjectionType<T>=undefined,sort:any=undefined) {
+    try {
+      const isolationFilter= {... this.getIsolationFilter(appuser)}
+      this.polishIsolationFilter(isolationFilter)      
+     
+      // console.log("initial search",filters)
+      const newfilters ={...filters,...isolationFilter}
+      await this.hook(appuser,HookType.beforeSearch, newfilters);
+      // console.log("before _find",newfilters)
+      // console.log("this.doc",this.doc)
+      const products = await this.doc.find(newfilters,projection).sort(sort);
+      // console.log("after search",products)
+      const productlist = products.map((p: T) => {
+        return p;
+      });
+      // console.log("after map",productlist)
+      await this.hook(appuser,HookType.afterSearch, productlist);
+      //   console.log(products);
+      return productlist;
+    } catch (err) {
+      throw new BadRequestException(err.message);
+    }
+    // return this;
+  }
+  async findById(appuser:UserContext,id: string) {
+    await this.hook(appuser,HookType.beforeFetchRecord, id);
+    const data = await this.search(appuser,{ _id: id });
+    await this.hook(appuser,HookType.afterFetchRecord, data);
+    if (data.length == 1) {
+      // console.log('data0', data[0]);
+      return data[0];
+    } else {
+      return null;
+    }
+  }
+
+
+  async create(appuser:UserContext, data:T) {
+    let result;
+    if(!data._id){
+      data._id = crypto.randomUUID()
+    }
+    if(this.withDocNumberFormat && !data[this.documentIdentityCode]){
+      await this.genNewDocNo(appuser,data)
+    }
+    console.log("DATA for create",data)
+    await this.hook(appuser,HookType.beforeCreate, data);
+    
+    let isolationFilter:any =  {...appuser.getCreateFilter()}    
+    isolationFilter = this.polishIsolationFilter(isolationFilter,data)      
+    
+    this.logger.debug("isolationFilter",'SimpleAppService')
+    this.logger.debug(isolationFilter,'SimpleAppService')
+    this.logger.debug("Create data before isolation",'SimpleAppService')
+    this.logger.debug(data,'SimpleAppService')
+    Object.assign(data, isolationFilter);
+    
+    await this.validateData(appuser,data);
+    this.logger.debug("Create record",'SimpleAppService')
+    this.logger.debug(data,'SimpleAppService')
+
+    this.applyNestedDateTime(appuser,data,'create')
+    const newdoc = new this.doc(data);
+    
+    result = await newdoc.save({session:appuser.getDBSession()})
+    
+    // this.doc.create(data)
+    // this.doc
+
+    // result = await newdoc.save()
+    await this.hook(appuser,HookType.afterCreate, result);
+
+    return result as T;
+  }
+  
+
+  applyNestedDateTime=(appuser:UserContext,data:any,transtype:string)=>{  
+
+    const props = Object.getOwnPropertyNames(data)
+    for(let i=0;i<props.length;i++){
+      const key = props[i]
+      //need to apply nested 
+      if(Array.isArray(data[key]) && data[key].length>0 && typeof data[key][0] == 'object'){
+        for(let j=0;j<data[key].length;j++){
+          this.applyNestedDateTime(appuser,data[key][j],transtype)
+        }
+      }else if(key == 'created'){
+        data['created'] = (transtype == 'create'  || !data['created']) ? new Date() .toISOString() : data['created']
+      }else if(key == 'createdby'){
+        data['createdby'] = (transtype == 'create'  || !data['createdby']) ? appuser.getUid() : data['createdby']
+      }else if(key == 'updated'){
+        data['updated'] = new Date() .toISOString()      
+      }else if(key == 'updatedby'){
+        data['updatedby'] = appuser.getUid()
+      }            
+    }
+
+  }
+  hook = async (appuser:UserContext,type: string, data?: any) => {
+    return true;
+  };
+  async validateData(appuser:UserContext,data: T) {
+    const ajv = new Ajv({ allErrors: true, useDefaults: true });
+    addFormats(ajv);
+    addErrors(ajv);
+
+    ajv.addFormat('tel', /^$|^\d{7,15}$/gm);
+    ajv.addFormat('text', /.*$/);
+    ajv.addFormat('html', /.*$/);
+    ajv.addFormat('documentno', /.*$/);
+    
+
+    ajv.addKeyword({ keyword: 'x-document-no', schemaType:'boolean' });
+    ajv.addKeyword({ keyword: 'x-document-label',schemaType: 'boolean' });
+    ajv.addKeyword({ keyword: 'x-document-status', schemaType: 'array' });
+    ajv.addKeyword({ keyword: 'x-document-api',schemaType: 'array' });
+    ajv.addKeyword({ keyword: 'x-page-type',schemaType:'string' }); // undefine mean no generate page
+    ajv.addKeyword({ keyword: 'x-ignore-autocomplete',schemaType: 'boolean' });
+    ajv.addKeyword({ keyword: 'x-isolation-type', schemaType: 'string' });
+    ajv.addKeyword({ keyword: 'x-document-type', schemaType: 'string' });
+    ajv.addKeyword({ keyword: 'x-document-name', schemaType: 'string' });
+    ajv.addKeyword({ keyword: 'x-collection-name',schemaType: 'string' });
+    ajv.addKeyword({ keyword: 'x-autocomplete-field', schemaType: 'boolean' });
+    ajv.addKeyword({ keyword: 'x-foreignkey', schemaType: 'string' });
+    ajv.addKeyword({ keyword: 'x-import-lib', schemaType: 'array' });
+    ajv.addKeyword({ keyword: 'x-compute', schemaType: 'object' });
+    ajv.addKeyword({ keyword: 'x-required-role', schemaType: 'array' });
+    
+    const issuccess = await this.hook(appuser,HookType.beforeValidation, data);
+    if (!issuccess) {
+      const errormsg: string[] = [];
+      for (let i = 0; i < this.errorlist.length; i++) {
+        errormsg.push(this.errorlist[i].message);
+      }
+      this.logger.log('run hook during validation');
+      throw new BadRequestException("Before validation hook failed",errormsg as HttpExceptionOptions);
+    }
+
+    let validate;
+    try {
+      validate = ajv.compile(this.jsonschema);
+    } catch (err) {
+      this.logger.error('compile error', err);
+      throw new ForbiddenException(err.message);
+    }
+      const valid = validate(data);
+      if (!valid) {
+        this.logger.error(JSON.stringify(validate.errors), 'validate errors:');
+        throw new BadRequestException("Data validation failed",validate.errors as HttpExceptionOptions);
+      }
+      await this.hook(appuser,HookType.afterValidation, data);
+    
+  }
+
+  polishIsolationFilter = (filterIsolation:any,data:any={}) =>{
+    if(this.isolationtype == 'none'){
+      delete filterIsolation['branchId']
+      delete filterIsolation['orgId']
+      delete filterIsolation['tenantId']
+    }
+    if(this.isolationtype == 'tenant' && !this.strictIsolation){
+      // delete filterIsolation['tenantId']
+      if(data['tenantId']){
+        filterIsolation['tenantId']=data['tenantId']
+      }
+      delete filterIsolation['branchId']
+      delete filterIsolation['orgId']      
+    }
+    if(this.isolationtype == 'org' && !this.strictIsolation){
+      // delete filterIsolation['tenantId']      
+      if(data['tenantId']){
+        filterIsolation['tenantId']=data['tenantId']
+      }
+      if(data['orgId']){
+        filterIsolation['orgId']=data['orgId']
+      }
+      // delete filterIsolation['orgId']      
+      delete filterIsolation['branchId']
+    }
+    return filterIsolation
+  }
+  async findIdThenDelete(appuser:UserContext,id: string): Promise<any> {
+    const deletedata = await this.findById(appuser,id);    
+    let dependency
+    try {
+      await this.hook(appuser,HookType.beforeDelete, id);
+      this.logger.debug('delete record',this.documentName, id);
+      dependency = await this.getRelatedRecords(id);
+      console.log('dependency', dependency);
+      if (!dependency) {
+        let filterIsolation = this.getIsolationFilter(appuser);
+        this.polishIsolationFilter(filterIsolation)        
+        
+        filterIsolation['_id'] =  id;
+        this.logger.debug('delete filter', filterIsolation);
+        const result = await this.doc.deleteOne(filterIsolation).session(appuser.getDBSession());
+        const deleteresult = {result:result, data: deletedata}
+        this.logger.debug(deleteresult, " delete result" +this.doc.collection.name,)
+        // this.doc.findByIdAndDelete(id)
+        await this.hook(appuser,HookType.afterDelete, deleteresult);
+        
+        //this.doc.findByIdAndDelete(id);
+        return deleteresult;
+      } else {
+        console.log("reject query",dependency)
+        
+        throw new ForbiddenException('Foreignkey constraint',dependency)
+      }
+    } catch (err) {
+      
+      throw new InternalServerErrorException(err);
+      //JSON.stringify(dependency),JSON.stringify(dependency)
+    }
+  }
+
+  // updateOne = async (appuser:UserContext,data: T) => {
+  //   this.doc.updateOne(data);
+  // };
+
+  findIdThenUpdate = async (appuser:UserContext,id: string, data: T,session:mongo.ClientSession=undefined) => {
+    const existingdata = await this.findById(appuser,id);
+    await this.hook(appuser,HookType.beforeUpdate, data);
+    // try {
+    Object.assign(data, appuser.getUpdateFilter());
+    Object.assign(existingdata, data);
+    delete existingdata['_id']
+    // existingdata['_id']=''
+    // console.log("newdata",data)
+    await this.validateData(appuser,data);
+    
+    const isolationFilter =  {...this.getIsolationFilter(appuser)}
+    this.polishIsolationFilter(isolationFilter)      
+
+    isolationFilter['_id'] = id;
+    this.applyNestedDateTime(appuser,data,'update')
+    const result = await this.doc.findOneAndUpdate(isolationFilter, data).session(appuser.getDBSession());
+    await this.hook(appuser,HookType.afterUpdate, data);
+    return result;
+    // } catch (err) {
+    //   throw new InternalServerErrorException(err.message);
+    // }
+  };
+
+  //find what foreign key constraint
+  async getRelatedRecords(id: string) {
+    this.logger.debug("get foreignkey for delete:",id)
+    
+    
+    if(foreignkeys === undefined){
+      this.logger.error("foreignkeys object undetected")
+      throw new InternalServerErrorException("foreignkeys object undetected")
+    }
+    
+    const foreignkeysettings = foreignkeys[this.documentName];
+    if(!foreignkeysettings){
+      return null
+    }
+    const propkeys = Object.getOwnPropertyNames(foreignkeysettings);
+    
+    if (propkeys.length > 0) {
+      //console.log('Have properties');
+      for (let i = 0; i < propkeys.length; i++) {
+        const collectionname = propkeys[i];
+        //console.log('run ', i, collectionname);
+        const fobjs = foreignkeysettings[propkeys[i]];
+        const collection = this.doc.db.collection(collectionname);
+        //single schema may have multiple foreign key link here, loop all
+        for (let j = 0; j < fobjs.length; j++) {
+          const fkey = fobjs[j] + '._id';
+          let filter = {}
+          filter[fkey] = id;
+         
+                    
+          const result = await collection.findOne(filter);          
+          if (result) {
+            this.logger.error(result,"related result found")
+            return result;
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * dummy ping
+   */
+  ping(...data) {
+    return `hello ${JSON.stringify(data)}`;
+  }
+  /**
+   * change property documentStatus for specific document, no workflow execution
+   * @param id
+   * @param docstatus
+   * @returns Promise
+   */
+  async setDocumentStatus(appuser:UserContext,id: string, docstatus: string) {
+    const partialdata: T = {} as T;
+    partialdata['documentStatus'] = docstatus;
+    return this.findIdThenUpdate(appuser,id, partialdata);
+  }
+
+  /**
+   * change property documentStatus for specific document, no workflow execution
+   * @param id
+   * @param docstatus
+   * @returns Promise
+   */
+  async executeWorkFlow(appuser:UserContext,id: string, bpmnname: string, docstatus: string) {
+    const data = await this.findById(appuser,id);
+    return "ok"
+    // Workflow.getInstance().executeWorkFlow(
+    //   id,
+    //   bpmnname,
+    //   docstatus,
+    //   data,
+    // );
+  }
+  
+
+
+  async genNewDocNo(appuser:UserContext,data:T){
+    const result = await this.docnogenerator.generateNextNumberFromDocument(appuser,this.documentType,data)
+    data[this.documentIdentityCode]=result    
+  }
+
+
+  async identifyUniqueKeys(appuser:UserContext,data:T){
+     /**
+     * 1. looping schemas identify what foreign key exists
+     * 2. loop through record obtain all foreign key value 
+     * 3. get all unique key value in array {product:['xxxx','yyyy'],customer:['aaa']}
+     */
+     const schema = this.jsonschema
+
+     //get all foreign keys catalogue
+     const collections = Object.getOwnPropertyNames(this.foreignkeys)
+ 
+     //obtain exists data in according foreign key
+     const pipelines :PipelineStage[] =[ {$match:{_id:false}}] //exclude data from current collection
+     const vdata = data['_doc']
+     const keystore = {}
+     collections.forEach((collectionname)=>{
+       const fks:string[] = this.foreignkeys[collectionname]
+       let  results:string[] = []
+       fks.forEach(fieldpath=>{        
+         const tmp = jsonpath.query(vdata,fieldpath).filter((item:string)=>item!='')
+         results = results.concat(tmp)        
+       })
+       
+       
+ 
+       if(results.length>0){  
+         console.log(results)
+         if(results.length>1){
+           results = uniq<string>(results)   
+         }
+         
+         keystore[collectionname]= results   
+         let addfield={$addFields:{collection:collectionname}}        
+         
+         const stagefilter:PipelineStage =  {
+           $unionWith: {coll:collectionname,pipeline: [{ $match: { _id: {$in:results}} },addfield,{$project:{collection:1}}, ]}          
+         }
+         pipelines.push(stagefilter)
+       }            
+     })
+ 
+     // this.doc.db.collection(collectionname);
+     const unionresult = await this.doc.aggregate(pipelines)
+     
+     if(!unionresult){
+       throw new InternalServerErrorException("Foreignkey check execution error",pipelines as HttpExceptionOptions)
+     }else{
+       let searchresult:any = {}
+       unionresult.forEach(item=>{
+         if(searchresult[item.collection]){
+           searchresult[item.collection].push(item._id)
+         }else{
+           searchresult[item.collection] = [item._id]
+         }
+       })
+ 
+       //search is it all foreign key exists in db
+       for(let i=0; i<collections.length; i++){
+         const collectionname = collections[i]
+         const keys:string[] = keystore[collectionname]
+         if(!keys){
+           continue
+         }
+         for(let k=0;k<keys.length; k++){
+           const key = keys[k]
+           if(!searchresult[collectionname].includes(key)){
+             console.log(`Foreignkey ${key} at collection ${collectionname} does not exist`)
+             throw new BadRequestException(`Foreignkey ${key} at collection ${collectionname} does not exist`)
+           }
+           else{
+            //  console.log(`${collectionname} - ${key} found`)      
+           }
+         }
+ 
+       }      
+       
+     }    
+     
+  }
+
+
+}

package/templates/nest/src/simpleapp/generate/types/index.ts.eta

@@ -0,0 +1,19 @@
+export type ForeignKey = {
+    _id: string
+    label: string
+}
+export type DocNumberFormatResult = {
+    formatId: string
+    formatName: string 
+    result: string
+}
+
+
+export type SearchBody = {
+    
+    filter?:Object;
+    
+    fields?: any[];
+    
+    sorts?: any[];
+}