@simitgroup/simpleapp-generator 2.0.0-f-alpha → 2.0.0-h-alpha

package/ReleaseNote.md

@@ -1,3 +1,9 @@
+[2.0.0h-alpha]
+1. add software license config folder
+
+[2.0.0g-alpha]
+1. fix create many no await cause transaction error
+
 [2.0.0f-alpha]
 1. add back document no and webhook
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simitgroup/simpleapp-generator",
-  "version": "2.0.0f-alpha",
+  "version": "2.0.0h-alpha",
   "description": "frontend nuxtjs and backend nests code generator using jsonschema",
   "main": "dist/index.js",
   "scripts": {

package/templates/nest/src/simple-app/.core/features/log/log.service.ts.eta

@@ -27,7 +27,7 @@ export class SimpleAppLogService {
           as: 'user',
           localField: 'createdBy',
           foreignField: 'uid',
-          pipeline: [{$match:{tenantId:appUser.getTenantId()}},{ $project: { fullName: 1 } }],
+          pipeline: [{ $match: { tenantId: appUser.getTenantId() } }, { $project: { fullName: 1 } }],
         },
       },
       { $unwind: '$user' },
@@ -35,13 +35,13 @@ export class SimpleAppLogService {
         $project: {
           _id: 1,
           fullName: '$user.fullName',
-          eventType:1,
+          eventType: 1,
           createdBy: 1,
           created: 1,
-          eventData: 1
+          eventData: 1,
         },
       },
-      {$sort:{created:1}}
+      { $sort: { created: 1 } },
     ]);
     // find({documentName:documentName,documentId:id},null,{session:appUser.getDBSession()})
 
@@ -93,6 +93,11 @@ export class SimpleAppLogService {
       alldata.push(eventdata);
     }
     const dbsession = appUser.getDBSession();
-    this.doc.insertMany(alldata, { session: dbsession });
+    try{
+      await this.doc.insertMany(alldata, { session: dbsession });  
+    }catch(e){
+      throw e
+    }
+    
   }
 }

package/templates/nest/src/simple-app/.core/features/mini-app/mini-app-manager/mini-app-manager-policy.service.ts.eta

@@ -5,7 +5,7 @@ import { PolicyService } from 'src/simple-app/.core/features/policy/policy.servi
 import { Role } from 'src/simple-app/.core/features/auth/role-guard/roles.enum';
 import { UserContext } from 'src/simple-app/.core/features/user-context/user.context';
 import { MiniApp } from '../dto';
-import * as plans from 'src/simple-app/features/subscription/license/plans'
+import * as licenseTypes from 'src/simple-app/config/license-types';
 @Injectable()
 export class MiniAppManagerPolicyService {
   readonly _RELEASED_STATUSES = [MiniAppStatusEnum.PUBLISHED];
@@ -29,15 +29,14 @@ export class MiniAppManagerPolicyService {
   }
 
   hasRequiredPlan(appUser: UserContext, miniApp: MiniApp) {
-    const currentPlan = appUser.tenantInfo.package;
+    const currentLicense = appUser.tenantInfo?.license ?? 'free';
     // const requiredPlans = miniApp.access.requiredPlans ?? [];
-    
-    if(plans[currentPlan]){
-      const plansetting = plans[currentPlan]()
-      return plansetting?.features?.advance?.features?.miniApp ?? false
 
-    }else{
-      return false
+    if (licenseTypes[currentLicense]) {
+      const licenseSetting = licenseTypes[currentLicense]();
+      return licenseSetting?.features?.advance?.features?.miniApp ?? false;
+    } else {
+      return false;
     }
     // if (_.isEmpty(requiredPlans)) return true;
 

package/templates/nest/src/simple-app/.core/features/mini-app/mini-app-manager/mini-app-manager.service.ts.eta

@@ -9,7 +9,7 @@ import { MiniAppInstallationService } from 'src/simple-app/.core/resources/mini-
 import _ from 'lodash';
 import { MiniAppManagerPolicyService } from './mini-app-manager-policy.service';
 import { MiniAppError } from './mini-app-manager.error';
-import * as plans from 'src/simple-app/features/subscription/license/plans'
+
 @Injectable()
 export class MiniAppManagerService {
   constructor(
@@ -82,7 +82,7 @@ export class MiniAppManagerService {
     });
 
     const permissions = this.getMiniAppActionAccess(appUser);
-    
+
     const installedMiniApps = miniAppInstallations.map((installation) => {
       const miniApp = miniApps.find((miniApp) => miniApp._id === installation.miniApp._id);
       if (!miniApp) {
@@ -175,10 +175,7 @@ export class MiniAppManagerService {
     };
   }
 
-  private getMiniAppActionAccess(appUser: UserContext) {
-    const currentPlan = appUser.tenantInfo.package; 
-    const planSetting =  plans[currentPlan]()
-
+  private getMiniAppActionAccess(appUser: UserContext) {    
     return {
       hasMiniAppFeature: this.policyService.hasFeature(appUser),
       canInstall: this.policyService.canInstall(appUser),

package/templates/nest/src/simple-app/.core/features/policy/policy.service.ts.eta

@@ -1,7 +1,7 @@
 import { Injectable } from '@nestjs/common';
 import { Role } from 'src/simple-app/.core/features/auth/role-guard/roles.enum';
 import { UserContext } from 'src/simple-app/.core/features/user-context/user.context';
-import * as plans from 'src/simple-app/features/subscription/license/plans'
+import * as licenseTypes from 'src/simple-app/config/license-types';
 @Injectable()
 export class PolicyService {
   private readonly _HIGH_PRIVILEGE_ROLES = [Role.SuperAdmin, Role.SuperUser, Role.TenantOwner];
@@ -27,12 +27,12 @@ export class PolicyService {
    * - plans/pro.ts
    * - plans/enterprise.ts
    */
-  hasFeature(appUser: UserContext, feature: keyof typeof this._FEATURES): boolean {    
-    const appPackage = appUser.tenantInfo.package;
-    const allowedPlans = this._FEATURES[feature];
-    const planSetting = plans[appPackage]();
-    const allowed = planSetting.features?.advance?.features[feature]  ?? false;
-    return allowed
+  hasFeature(appUser: UserContext, feature: keyof typeof this._FEATURES): boolean {
+    const appLicense = appUser.tenantInfo?.license ?? 'free';
+    // const allowedPlans = this._FEATURES[feature];
+    const licenseSetting = licenseTypes[appLicense]();
+    const allowed = licenseSetting.features?.advance?.features[feature] ?? false;
+    return allowed;
   }
 
   can(appUser: UserContext, role: Role) {

package/templates/nest/src/simple-app/.core/features/profile/profile.service.ts.eta

@@ -50,11 +50,13 @@ export class ProfileService {
     this.logger.verbose(`get userprofile for ${appuser.getUid()} for tenantId ${accessTenantId}`, 'getProfile');
     const userinfo: UserContextInfo = await appuser.getUserInfo();
 
-    if (userinfo._id == '') {
+    if (!userinfo._id) {
       this.logger.warn('unknown _id for ', appuser.getUid());
 
       let newprofile;
+      
       if (accessTenantId == 0) {
+      
         newprofile = await this.createUserProfile(appuser);
         newprofile['time'] = new Date().toISOString();
         return newprofile;

package/templates/nest/src/simple-app/.core/features/queue/queue-base/queue-base.consumer.ts.eta

@@ -31,12 +31,11 @@ export abstract class BaseQueueConsumer extends WorkerHost {
   async startSession(appUser: UserContext) {
     const session = await this.connection.startSession();
     appUser.setDBSession(session);
-    appUser.getDBSession().startTransaction({ readPreference: 'primary' });
   }
 
   async process(job: Job) {
     // console.log("process job", job.data)
-    const { userContext, payload } = job.data
+    const { userContext, payload } = job.data;
 
     const appUser = this.createUserContext(userContext.user);
     await this.startSession(appUser);
@@ -46,13 +45,16 @@ export abstract class BaseQueueConsumer extends WorkerHost {
       // this.queueUserContext.assign(userContext);
 
       await this.dispatch(appUser, job, payload);
-
-      await appUser.getDBSession().commitTransaction();
+      if(appUser.getDBSession().inTransaction()) {
+        await appUser.getDBSession().commitTransaction();
+      }
       return {
         success: true,
       };
     } catch (e) {
-      await appUser.getDBSession().abortTransaction();
+      if(appUser.getDBSession().inTransaction()) {
+        await appUser.getDBSession().abortTransaction();
+      }
       throw e;
     } finally {
       appUser.getDBSession().endSession();

package/templates/nest/src/simple-app/.core/framework/base/simple-app.service.ts.eta

@@ -24,6 +24,7 @@ import { UserContext } from '../../features/user-context/user.context';
 import { RunWebhookService } from '../../features/webhook/run-webhook.service';
 import { UniqueKeyExistResponse, DeleteResultType, IsolationType, MoreProjectionType, SchemaFields, TextSearchBody, PatchManyRequest } from '../schemas';
 import { SimpleAppLogService } from '../../features/log/log.service';
+import { ProcessErrorException } from 'src/simple-app/features/exception/process-error.exception';
 
 @Injectable()
 export class SimpleAppService<T extends SchemaFields> {
@@ -62,10 +63,19 @@ export class SimpleAppService<T extends SchemaFields> {
   protected withDocNumberFormat = false;
   protected foreignkeys = {};
   private eventEmitter: EventEmitter2;
-  private logSvc:SimpleAppLogService;
+  private logSvc: SimpleAppLogService;
   // protected userprovider = new UserContext() ;
 
-  constructor(doctype: string, docname: string, newdoc: Model<T>, isolationtype: IsolationType = IsolationType.org, eventEmitter: EventEmitter2, docnogenerator: SimpleAppDocumentNoFormatService,logSvc: SimpleAppLogService,runWebHook: RunWebhookService) {
+  constructor(
+    doctype: string,
+    docname: string,
+    newdoc: Model<T>,
+    isolationtype: IsolationType = IsolationType.org,
+    eventEmitter: EventEmitter2,
+    docnogenerator: SimpleAppDocumentNoFormatService,
+    logSvc: SimpleAppLogService,
+    runWebHook: RunWebhookService,
+  ) {
     // console.log("-------init simpleapp service abstract class -------userprovider=",typeof this.userprovider)
     this.eventEmitter = eventEmitter;
     this.documentType = doctype.toUpperCase();
@@ -73,8 +83,8 @@ export class SimpleAppService<T extends SchemaFields> {
     this.doc = newdoc;
     this.docnogenerator = docnogenerator;
     this.isolationtype = isolationtype;
-    this.logSvc = logSvc
-    this.runWebHook = runWebHook
+    this.logSvc = logSvc;
+    this.runWebHook = runWebHook;
     // this.tenantdoc = tenantdoc
   }
   getDocumentType = () => this.documentType;
@@ -348,100 +358,105 @@ export class SimpleAppService<T extends SchemaFields> {
     }
   }
 
-  async createManyWithId(appuser: UserContext, datas: T[]) {
-    if (Array.isArray(datas)) {
-      for (let i = 0; i < datas.length; i++) {
-        const data = datas[i];
-        let isolationFilter: any = { ...appuser.getCreateFilterWithId() };
-        isolationFilter = this.polishIsolationFilter(isolationFilter, data);
-
-        Object.assign(data, isolationFilter);
-        this.reCalculateValue(data);
-        await this.validateData(appuser, data);
-        this.applyNestedDateTime(appuser, data, 'create');
-      }
-
-      const dbsession = appuser.getDBSession();
-      if (dbsession && !dbsession.inTransaction()) {
-        dbsession.startTransaction({ readPreference: 'primary' });
-      }
-
-      const result = await this.doc.insertMany(datas, { session: dbsession });
-      await this.addManyAuditEvents(appuser, this.documentName, 'createMany', datas);
-      for (let i = 0; i < datas.length; i++) {
-        appuser.addInsertedRecordId(this.documentName, datas[i]._id);
-      }
-      return result;
-    } else {
-      throw new BadRequestException(this.getDocumentType() + ': create many only support array');
-    }
-  }
+  // seems no use, and confusing
+  // async createManyWithId(appuser: UserContext, datas: T[]) {
+  //   if (Array.isArray(datas)) {
+  //     for (let i = 0; i < datas.length; i++) {
+  //       const data = datas[i];
+  //       let isolationFilter: any = { ...appuser.getCreateFilterWithId() };
+  //       isolationFilter = this.polishIsolationFilter(isolationFilter, data);
+
+  //       Object.assign(data, isolationFilter);
+  //       this.reCalculateValue(data);
+  //       await this.validateData(appuser, data);
+  //       this.applyNestedDateTime(appuser, data, 'create');
+  //     }
+
+  //     const dbsession = appuser.getDBSession();
+  //     if (dbsession && !dbsession.inTransaction()) {
+  //       dbsession.startTransaction({ readPreference: 'primary' });
+  //     }
+
+  //     const result = await this.doc.insertMany(datas, { session: dbsession });
+  //     await this.addManyAuditEvents(appuser, this.documentName, 'createMany', datas);
+  //     for (let i = 0; i < datas.length; i++) {
+  //       appuser.addInsertedRecordId(this.documentName, datas[i]._id);
+  //     }
+  //     return result;
+  //   } else {
+  //     throw new BadRequestException(this.getDocumentType() + ': create many only support array');
+  //   }
+  // }
 
   /**
    * create many from array with hooks (temporary used for generate sample data only)
    * @param appuser
    * @param datas
    */
-  async createManyWithHook(appuser: UserContext, datas: T[]) {
-    if (Array.isArray(datas)) {
-      for (let i = 0; i < datas.length; i++) {
-        const data = datas[i];
-
-        let result;
-        const dbsession = appuser.getDBSession();
-        if (dbsession && !dbsession.inTransaction()) {
-          dbsession.startTransaction({ readPreference: 'primary' });
-        }
-
-        if (this.withDocNumberFormat && !data[this.documentIdentityCode]) {
-          await this.genNewDocNo(appuser, data);
-        }
-
-        let isolationFilter: any = { ...appuser.getCreateFilterWithId() };
-        isolationFilter = this.polishIsolationFilter(isolationFilter, data);
-
-        Object.assign(data, isolationFilter);
-        this.reCalculateValue(data);
-        await this.validateData(appuser, data);
-        this.applyNestedDateTime(appuser, data, 'create');
-
-        //new way of hook
-        await this.runEvent(appuser, this.setHookName('beforeCreate'), { data: data }, false);
-
-        const newdoc = new this.doc(data);
-
-        try {
-          result = await newdoc.save({ session: dbsession });
-          await this.addAuditEvent(appuser, this.documentName, result._id, 'create', data);
-          appuser.addInsertedRecordId(this.documentName, result._id);
-        } catch (err) {
-          this.logger.error(err);
-          const processdata = await this.runEvent(appuser, 'processdata.processError', {
-            err: err,
-          });
-
-          if (!processdata) {
-            throw new InternalServerErrorException(err);
-          } else {
-            throw new CustomException(processdata.code, processdata.msg);
-          }
-        }
-
-        try {
-          //new way of hook
-          await this.runEvent(appuser, this.setHookName('afterCreate'), { data: data }, false);
-          await this.callWebhook(appuser, 'create', result);
-
-          // return result as T;
-        } catch (err) {
-          throw new InternalServerErrorException(`createHook ${this.documentType} error: ${JSON.stringify(err)}`, `${this.documentType} createHook error`);
-        }
-      }
-    } else {
-      throw new BadRequestException(this.getDocumentType() + ': create many only support array');
-    }
-    return 'ok';
-  }
+  //seems nobody use. also confusing
+  // async createManyWithHook(appuser: UserContext, datas: T[]) {
+  //   if (Array.isArray(datas)) {
+  //     for (let i = 0; i < datas.length; i++) {
+  //       const data = datas[i];
+
+  //       let result;
+  //       const dbsession = appuser.getDBSession();
+  //       if (dbsession && !dbsession.inTransaction()) {
+  //         dbsession.startTransaction({ readPreference: 'primary' });
+  //       }
+
+  //       if (this.withDocNumberFormat && !data[this.documentIdentityCode]) {
+  //         await this.genNewDocNo(appuser, data);
+  //       }
+
+  //       let isolationFilter: any = { ...appuser.getCreateFilterWithId() };
+  //       isolationFilter = this.polishIsolationFilter(isolationFilter, data);
+
+  //       Object.assign(data, isolationFilter);
+  //       this.reCalculateValue(data);
+  //       await this.validateData(appuser, data);
+  //       this.applyNestedDateTime(appuser, data, 'create');
+
+  //       //new way of hook
+  //       await this.runEvent(appuser, this.setHookName('beforeCreate'), { data: data }, false);
+
+  //       const newdoc = new this.doc(data);
+
+  //       try {
+  //         result = await newdoc.save({ session: dbsession });
+  //         await this.addAuditEvent(appuser, this.documentName, result._id, 'create', data);
+  //         appuser.addInsertedRecordId(this.documentName, result._id);
+  //       } catch (err) {
+  //         this.logger.error(err);
+  //         throw new ProcessErrorException('ERR_CREATE_MANY',err.message,{
+  //           err:err
+  //         })
+  //         // const processdata = await this.runEvent(appuser, 'processdata.processError', {
+  //         //   err: err,
+  //         // });
+
+  //         // if (!processdata) {
+  //         //   throw new InternalServerErrorException(err);
+  //         // } else {
+  //         //   throw new CustomException(processdata.code, processdata.msg);
+  //         // }
+  //       }
+
+  //       try {
+  //         //new way of hook
+  //         await this.runEvent(appuser, this.setHookName('afterCreate'), { data: data }, false);
+  //         await this.callWebhook(appuser, 'create', result);
+
+  //         // return result as T;
+  //       } catch (err) {
+  //         throw new InternalServerErrorException(`createHook ${this.documentType} error: ${JSON.stringify(err)}`, `${this.documentType} createHook error`);
+  //       }
+  //     }
+  //   } else {
+  //     throw new BadRequestException(this.getDocumentType() + ': create many only support array');
+  //   }
+  //   return 'ok';
+  // }
 
   /**
    * create many from array, for performance reason it submit all item in 1 go, so it won't implement hooks
@@ -464,76 +479,85 @@ export class SimpleAppService<T extends SchemaFields> {
       if (dbsession && !dbsession.inTransaction()) {
         dbsession.startTransaction({ readPreference: 'primary' });
       }
-      const result = await this.doc.insertMany(datas, { session: dbsession });
-      await this.addManyAuditEvents(appuser, this.documentName, 'createMany', datas);
-      return result;
+      
+      try{
+        const result = await this.doc.insertMany(datas, { session: dbsession });
+        await this.addManyAuditEvents(appuser, this.documentName, 'createMany', datas);  
+        return result;
+      }catch(e){
+        throw e
+      }
+      
+      
     } else {
       throw new BadRequestException(this.getDocumentType() + ': create many only support array');
     }
   }
-  async createWithId(appuser: UserContext, data: T) {
-    let result;
 
-    if (!data._id) {
-      data._id = crypto.randomUUID();
-    }
-    const dbsession = appuser.getDBSession();
-    if (dbsession && !dbsession.inTransaction()) {
-      dbsession.startTransaction({ readPreference: 'primary' });
-    }
-
-    this.logger.debug('this.withDocNumberFormat :' + this.withDocNumberFormat + '  && ' + '!data[this.documentIdentityCode] ==' + !data[this.documentIdentityCode]);
-    if (this.withDocNumberFormat && !data[this.documentIdentityCode]) {
-      await this.genNewDocNo(appuser, data);
-    }
-
-    let isolationFilter: any = { ...appuser.getCreateFilterWithId() };
-    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);
-    this.reCalculateValue(data);
-    await this.validateData(appuser, data);
-    this.logger.debug(data, `after create validation`);
-    this.applyNestedDateTime(appuser, data, 'create');
-
-    //new way of hook
-
-    await this.runEvent(appuser, this.setHookName('beforeCreate'), { data: data }, false);
-
-    this.logger.debug(data, `Create Record ${this.documentName}`);
-    const newdoc = new this.doc(data);
-    await this.identifyForeignKeys(appuser, data);
-    try {
-      result = await newdoc.save({ session: dbsession });
-      await this.addAuditEvent(appuser, this.documentName, result._id, 'create', data);
-      appuser.addInsertedRecordId(this.documentName, result._id);
-    } catch (err) {
-      this.logger.error(err);
-      const processdata = await this.runEvent(appuser, 'processdata.processError', {
-        err: err,
-      });
-
-      if (!processdata) {
-        throw new InternalServerErrorException(err);
-      } else {
-        throw new CustomException(processdata.code, processdata.msg);
-      }
-    }
-
-    try {
-      //new way of hook
-      await this.runEvent(appuser, this.setHookName('afterCreate'), { data: result }, false);
-
-      await this.callWebhook(appuser, 'create', result);
-      return result as T;
-    } catch (err) {
-      throw new InternalServerErrorException(`createHook ${this.documentType} error: ${JSON.stringify(err)}`, `${this.documentType} createHook error`);
-    }
-  }
+  //seems nobody use, also confusing
+  // async createWithId(appuser: UserContext, data: T) {
+  //   let result;
+
+  //   if (!data._id) {
+  //     data._id = crypto.randomUUID();
+  //   }
+  //   const dbsession = appuser.getDBSession();
+  //   if (dbsession && !dbsession.inTransaction()) {
+  //     dbsession.startTransaction({ readPreference: 'primary' });
+  //   }
+
+  //   this.logger.debug('this.withDocNumberFormat :' + this.withDocNumberFormat + '  && ' + '!data[this.documentIdentityCode] ==' + !data[this.documentIdentityCode]);
+  //   if (this.withDocNumberFormat && !data[this.documentIdentityCode]) {
+  //     await this.genNewDocNo(appuser, data);
+  //   }
+
+  //   let isolationFilter: any = { ...appuser.getCreateFilterWithId() };
+  //   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);
+  //   this.reCalculateValue(data);
+  //   await this.validateData(appuser, data);
+  //   this.logger.debug(data, `after create validation`);
+  //   this.applyNestedDateTime(appuser, data, 'create');
+
+  //   //new way of hook
+
+  //   await this.runEvent(appuser, this.setHookName('beforeCreate'), { data: data }, false);
+
+  //   this.logger.debug(data, `Create Record ${this.documentName}`);
+  //   const newdoc = new this.doc(data);
+  //   await this.identifyForeignKeys(appuser, data);
+  //   try {
+  //     result = await newdoc.save({ session: dbsession });
+  //     await this.addAuditEvent(appuser, this.documentName, result._id, 'create', data);
+  //     appuser.addInsertedRecordId(this.documentName, result._id);
+  //   } catch (err) {
+  //     this.logger.error(err);
+  //     const processdata = await this.runEvent(appuser, 'processdata.processError', {
+  //       err: err,
+  //     });
+
+  //     if (!processdata) {
+  //       throw new InternalServerErrorException(err);
+  //     } else {
+  //       throw new CustomException(processdata.code, processdata.msg);
+  //     }
+  //   }
+
+  //   try {
+  //     //new way of hook
+  //     await this.runEvent(appuser, this.setHookName('afterCreate'), { data: result }, false);
+
+  //     await this.callWebhook(appuser, 'create', result);
+  //     return result as T;
+  //   } catch (err) {
+  //     throw new InternalServerErrorException(`createHook ${this.documentType} error: ${JSON.stringify(err)}`, `${this.documentType} createHook error`);
+  //   }
+  // }
 
   async create(appuser: UserContext, data: T, noStartTransaction: boolean = false) {
     let result;
@@ -1038,7 +1062,7 @@ export class SimpleAppService<T extends SchemaFields> {
       return createresult;
     } else {
       const updateresult = await this.findIdThenPatch(appuser, id, data);
-      const finaldata = await this.findById(appuser, id);      
+      const finaldata = await this.findById(appuser, id);
       await this.runEvent(appuser, this.setHookName('afterSetStatus'), { docStatus: docstatus, data: finaldata }, false);
       await this.addAuditEvent(appuser, this.documentName, id, docstatus, data);
 
@@ -1078,10 +1102,9 @@ export class SimpleAppService<T extends SchemaFields> {
    */
   async runEvent(appuser: UserContext, eventName: string, payloads: any, enforce: boolean = true) {
     try {
-
       if (enforce && !this.eventEmitter.hasListeners(eventName)) {
         throw new InternalServerErrorException(`${eventName} seems no listener`);
-      } else if (this.eventEmitter.hasListeners(eventName)) {        
+      } else if (this.eventEmitter.hasListeners(eventName)) {
         const res = await this.eventEmitter.emitAsync(eventName, appuser, payloads);
 
         if (!res) {
@@ -1276,16 +1299,16 @@ export class SimpleAppService<T extends SchemaFields> {
   //only realtime webhook supported at this moment
   async callWebhook(appuser: UserContext, actionName: string, data: any) {
     try {
-      await this.runWebHook.run(appuser, this.documentName, actionName, data);      
+      await this.runWebHook.run(appuser, this.documentName, actionName, data);
     } catch (e) {
       throw new InternalServerErrorException(e);
     }
   }
 
   async addAuditEvent(appUser: UserContext, documentName: string, id: string, eventType: string, data: any) {
-    await this.logSvc.addEvent(appUser,documentName,id,eventType,data)    
+    await this.logSvc.addEvent(appUser, documentName, id, eventType, data);
   }
   async addManyAuditEvents(appUser: UserContext, documentName: string, eventType: string, datas: any) {
-    await this.logSvc.addManyEvents(appUser,documentName,eventType,datas)    
+    await this.logSvc.addManyEvents(appUser, documentName, eventType, datas);
   }
 }

package/templates/nest/src/simple-app/config/license-types/index.ts._eta

@@ -0,0 +1 @@
+export const license1 = {id:"app"}

package/templates/nuxt/components/user/UserTenantPicker.vue._eta

@@ -13,7 +13,12 @@
           <NuxtLink :to="`/${item.xOrg}`" external>
             <div class="flex flex-row gap-2 hover:bg-primary-100">
               <div class="min-w-14 p=2">
-                <ImageOrganization :orgRecordId="item.orgRecordId" :size="12" />
+                <ImageOrganization
+                  v-if="tenant?.permissions.length > 0"
+                  class="w-10 h-10"
+                  :orgRecordId="tenant?.permissions[0]?.orgRecordId"
+                  :size="PHOTOSIZE.S40"
+                />
               </div>
               <div class="flex flex-col w-full justify-end gap-2">
                 <div class="flex flex-row gap-2">