@simitgroup/simpleapp-generator 1.6.7-o-alpha → 2.0.0-b-alpha

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

@@ -0,0 +1,196 @@
+import { OnWorkerEvent, WorkerHost } from '@nestjs/bullmq';
+import { InjectConnection, InjectModel } from '@nestjs/mongoose';
+import axios from 'axios';
+import { Job } from 'bullmq';
+import { Connection, Model } from 'mongoose';
+import { UserContext } from '../../user-context/user.context';
+import { QueueUserContext } from '../queue-user-context/queue-user-context.service';
+import { Queuejob } from '../queue.type';
+// import { QueueName } from '../queue.enum';
+import { forwardRef, Inject, InternalServerErrorException } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import _ from 'lodash';
+
+export abstract class BaseQueueConsumer extends WorkerHost {
+  // protected abstract readonly processor: QueueName;
+  protected abstract readonly processor: string;
+
+  constructor(
+    @Inject(forwardRef(() => QueueUserContext)) protected readonly queueUserContext: QueueUserContext,
+    @InjectModel('Queuejob') protected queueJobModel: Model<Queuejob>,
+    @InjectConnection() private readonly connection: Connection,
+    protected eventEmitter: EventEmitter2,
+  ) {
+    super();
+  }
+
+  createUserContext(user) {
+    return this.queueUserContext.create(user);
+  }
+
+  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 appUser = this.createUserContext(userContext.user);
+    await this.startSession(appUser);
+
+    try {
+      const { userContext, payload } = job.data;
+      // this.queueUserContext.assign(userContext);
+
+      await this.dispatch(appUser, job, payload);
+
+      await appUser.getDBSession().commitTransaction();
+      return {
+        success: true,
+      };
+    } catch (e) {
+      await appUser.getDBSession().abortTransaction();
+      throw e;
+    } finally {
+      appUser.getDBSession().endSession();
+    }
+  }
+
+  private async dispatch(appUser: UserContext, job: Job, payload: any) {
+    const pascalJobName = _.upperFirst(_.camelCase(job.name));
+    const methodName = `handle${pascalJobName}`;
+
+    const handler = (this as any)[methodName];
+    if (typeof handler !== 'function') {
+      job.log(`[WARN] No handler found for job: ${job.name} (expected ${methodName})`);
+      return;
+    }
+
+    await handler.call(this, appUser, job, payload);
+  }
+
+  protected async updateQueueJobRecord(job: Job, status: 'completed' | 'failed', result: any) {
+    await this.queueJobModel.updateOne(
+      {
+        'job.id': job.id,
+        'job.name': job.name,
+        'job.processor': this.processor,
+      },
+      {
+        'job.status': status,
+        updated: new Date().toISOString(),
+        result: status === 'completed' ? result : undefined,
+        error: status === 'failed' ? result : undefined,
+      },
+    );
+  }
+
+  @OnWorkerEvent('active')
+  onActive(job: Job) {
+    job.log(`Processing job ${job.id}`);
+  }
+
+  // @OnWorkerEvent('closed')
+  // onClosed() {
+  //   console.log(`closed`);
+  // }
+
+  // @OnWorkerEvent('closing')
+  // onClosing(msg: string) {
+  //   console.log(`closing: ${msg}`);
+  // }
+
+  @OnWorkerEvent('completed')
+  onCompleted(job: Job, result: any, prev: string) {
+    const status = 'completed';
+    job.log('[COMPLETED]');
+    this.updateQueueJobRecord(job, status, result);
+    this.notify(job, status, {});
+  }
+
+  // @OnWorkerEvent('drained')
+  // onDrained() {
+  //   console.log(`drained`);
+  // }
+
+  // @OnWorkerEvent('error')
+  // onError(failedReason: Error) {
+  //   console.log(`Error: ${failedReason}`);
+  // }
+
+  @OnWorkerEvent('failed')
+  onFailed(job: Job, error: Error, prev: string) {
+    const status = 'failed';
+    job.log('[Failed]');
+    const errorData = {
+      // @ts-expect-error Status is valid
+      status: error?.status,
+      name: error?.name,
+      message: error?.message,
+    };
+
+    this.updateQueueJobRecord(job, status, errorData);
+    this.notify(job, status, errorData);
+  }
+
+  // @OnWorkerEvent('paused')
+  // onPaused() {
+  //   console.log(`paused`);
+  // }
+
+  // @OnWorkerEvent('progress')
+  // onProgress(job: Job, progress: JobProgress) {
+  //   console.log(`progress`);
+  // }
+
+  // @OnWorkerEvent('ready')
+  // onReady() {
+  //   console.log(`ready`);
+  // }
+
+  // @OnWorkerEvent('resumed')
+  // onResumed() {
+  //   console.log(`Resumed`);
+  // }
+
+  // @OnWorkerEvent('stalled')
+  // onStalled() {
+  //   console.log(`stalled`);
+  // }
+
+  async notify(job: Job, status: string, data?: any) {
+    const xOrg = job.data?.userContext?.xOrg;
+    if (!xOrg) {
+      job.log('[NOTIFY] Not found X-Org, Failed to notify frontend');
+      return;
+    }
+    const frontendurl = process.env.FRONTEND_URL ?? 'https://localhost:8080';
+    const url = `${frontendurl}/api/${xOrg}/queue/notify`;
+    await axios.post(url, {
+      id: job.id,
+      name: job.name,
+      processor: this.processor,
+      status,
+      data,
+    });
+
+    job.log(`[NOTIFY] Process End ${url}`);
+  }
+
+  async runEvent(appuser: UserContext, eventName: string, payloads: any) {
+    const res = await this.eventEmitter.emitAsync(eventName, appuser, payloads);
+    if (!this.eventEmitter.hasListeners(eventName)) {
+      throw new InternalServerErrorException(`${eventName} seems no listener`);
+    }
+    if (!res) {
+      throw new InternalServerErrorException(`${eventName} is invalid worker`);
+    }
+
+    const result = res[0];
+    if (result?.name && result?.name.includes('Exception')) throw result;
+    return result;
+  }
+}

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

@@ -0,0 +1,147 @@
+import { Job } from 'bullmq';
+// import { QueueName } from '../queue.enum';
+import { InjectModel } from '@nestjs/mongoose';
+import axios from 'axios';
+import { Model } from 'mongoose';
+import { QueuePayload } from '../queue.type';
+import { QueueJob,QueueJobProducerResponse } from 'src/simple-app/.core/resources/queue-job/queue-job.schema';
+import { UserContext } from 'src/simple-app/.core/features/user-context/user.context';
+
+export abstract class QueueBaseProducer {
+  // protected abstract readonly processor: QueueName;
+  protected abstract readonly processor: string;
+
+  constructor(@InjectModel('QueueJob') protected queueJobModel: Model<QueueJob>) {}
+
+  protected buildPayload<T>(appUser: UserContext, payload: T) {
+    const data: QueuePayload.WithUserContext<T> = {
+      userContext: {
+        user: {
+          _id: appUser.getId(),
+          uid: appUser.getUid(),
+          uname: appUser.getUname(),
+          fullName: appUser.getFullname(),
+          email: appUser.getEmail(),
+          timeZone: appUser.getTimeZone(),
+          currency: appUser.getCurrency(),
+          country: appUser.getCountry(),
+          offsetMinute: appUser.getOffsetMinute(),
+          tenantId: appUser.getTenantId(),
+          orgId: appUser.getOrgId(),
+          branchId: appUser.getBranchId(),
+        },
+        xOrg: appUser.getXOrg(),
+      },
+      payload,
+    };
+
+    return data;
+  }
+
+  protected buildResponse(job: Job): QueueJobProducerResponse {
+    return {
+      id: job.id,
+      name: job.name,
+      processor: this.processor,
+    };
+  }
+
+  protected async createQueueJob<T>(appUser: UserContext, job: Job, payload: T, title: string) {
+    job.log(`Job Created: ${title}`);
+    await this.createQueueJobRecord(appUser, job, payload, title);
+    await this.notify(job, 'waiting', title);
+  }
+
+  /**
+   * Note:
+   * We use `queueJobModel.create` directly instead of `queueJobService.create`
+   * because using the service would run inside the active MongoDB transaction,
+   * which can lead to transaction errors.
+   *
+   * Example:
+   * ```
+   * const job = await this.queue.add(QueueTuitionClassJob.GENERATE_SCHEDULE, data);
+   * this.createJob(appUser, job);
+   * ```
+   *
+   * Context:
+   * Creating a tuition class involves multiple steps, all wrapped in a transaction:
+   * 1. Create tuition class
+   * 2. Generate schedule <-- queued
+   *
+   * Problem:
+   * - `queueJobService.create` runs inside the current MongoDB transaction.
+   * - After `this.queue.add(...)`, BullMQ may start processing the job immediately.
+   * - If the worker touches MongoDB while the transaction is still open,
+   *   MongoDB throws: "Transaction with { txnNumber: X } has been committed."
+   *
+   * Solution:
+   * - Write the queue job record directly with `queueJobModel.create`
+   *   (bypasses transaction, no session).
+   * - Ensure the main transaction can commit before the queue worker runs.
+   * - This avoids conflicts between the active transaction and the worker.
+   */
+  protected async createQueueJobRecord<T>(appUser: UserContext, job: Job, payload: T, title: string) {
+    try {
+      const doc = new this.queueJobModel({
+        _id: crypto.randomUUID(),
+        created: new Date().toISOString(),
+        updated: new Date().toISOString(),
+        createdBy: appUser.getUid(),
+        updatedBy: appUser.getUid(),
+        tenantId: appUser.getTenantId(),
+        orgId: appUser.getOrgId(),
+        branchId: appUser.getBranchId(),
+
+        job: {
+          id: job.id,
+          name: job.name,
+          processor: this.processor,
+          status: 'waiting',
+          title,
+        },
+
+        payload,
+      });
+      const res = await doc.save({ session: appUser.getDBSession() });
+    } catch (e) {
+      throw e;
+    }
+    // this.queueJobModel.create({,{
+    //   session:appUser.getDBSession()
+    // });
+
+    // this.queueJobService.create(
+    //   appUser,
+    //   {
+    //     job: {
+    //       id: job.id,
+    //       name: job.name,
+    //       processor: this.processor, //QueueName.TUITION_CLASS,
+    //       status: 'pending',
+    //       title: '',
+    //     },
+    //   },
+    //   true,
+    // );
+  }
+
+  async notify(job: Job, status: string, title: string) {
+    const xOrg = job.data?.userContext?.xOrg;
+    if (!xOrg) {
+      job.log('[NOTIFY] Not found X-Org, Failed to notify frontend');
+      return;
+    }
+
+    const url = `${process.env.FRONTEND_URL}/api/${xOrg}/queue/notify`;
+    await axios.post(url, {
+      id: job.id,
+      name: job.name,
+      processor: this.processor,
+      title,
+      status,
+    });
+
+    job.log(`[NOTIFY] Job Created: ${url}`);
+  }
+}

package/templates/nest/src/simple-app/.core/features/queue/queue-user-context/queue-user-context.service.ts.eta

@@ -0,0 +1,35 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { UserContext } from 'src/simple-app/.core/features/user-context/user.context';
+import { SimpleAppRobotUserService } from '../../user-context/robot-user.service';
+import { MiniAppInstallation } from '../../mini-app/dto';
+import { Permission } from 'src/simple-app/.core/resources/permission/permission.schema';
+import { User } from 'src/simple-app/.core/resources/user/user.schema';
+
+@Injectable()
+export class QueueUserContext {
+  public appUser: UserContext;
+
+  constructor(
+    @InjectModel('User') private userModel: Model<User>,
+    @InjectModel('Permission') private permModel: Model<Permission>,
+    @InjectModel('MiniAppInstallation') private miniAppInstallationModel: Model<MiniAppInstallation>,
+    private robotUserSvc: SimpleAppRobotUserService
+  ) { }
+
+  create(user) {
+    return this.robotUserSvc.createDumyAppUser(user)
+  }
+
+  //   assign(userContext: QueuePayload.UserContext) {
+  //     const userPayload = userContext.user;
+  //     const xOrg = userContext.xOrg;
+
+  //     this.appUser.setAsStaticUser(userPayload.uid, userPayload.uname, userPayload.fullName, userPayload.email, xOrg);
+  //     this.appUser.setTimeZone(userPayload.timeZone);
+  //     this.appUser.setCountry(userPayload.country);
+  //     this.appUser.setCurrency(userPayload.currency);
+  //     this.appUser.setOffsetMinute(userPayload.offsetMinute);
+  //   }
+}

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

@@ -0,0 +1,24 @@
+import { Module } from '@nestjs/common';
+import { QueueJobModule } from 'src/simple-app/.core/resources/queue-job/queue-job.module';
+import { QueueUserContext } from './queue-user-context/queue-user-context.service';
+
+import { MongooseModule } from '@nestjs/mongoose';
+import { MiniAppInstallationMongoSchema } from '../../resources/mini-app-installation/mini-app-installation.model';
+import { PermissionMongoSchema } from '../../resources/permission/permission.model';
+import { UserMongoSchema } from '../../resources/user/user.model';
+import { SimpleAppUserContextModule } from '../user-context/user-context.module';
+
+@Module({
+  imports: [
+    SimpleAppUserContextModule,
+    MongooseModule.forFeature([
+      { name: 'User', schema: UserMongoSchema },
+      { name: 'Permission', schema: PermissionMongoSchema },
+      { name: 'MiniAppInstallation', schema: MiniAppInstallationMongoSchema },
+    ]),
+    QueueJobModule,
+  ],
+  providers: [QueueUserContext],
+  exports: [QueueUserContext, QueueJobModule],
+})
+export class SimpleAppQueueModule { }

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

@@ -0,0 +1,75 @@
+export namespace QueuePayload {
+  export type UserContext = {
+    user: {
+      _id: string;
+      uid: string;
+      uname: string;
+      fullName: string;
+      email: string;
+      timeZone: string;
+      currency: string;
+      country: string;
+      offsetMinute: number;
+      tenantId:number;
+      orgId:number;
+      branchId:number;
+    };
+    xOrg: string;
+  };
+
+  export type WithUserContext<T> = {
+    userContext: UserContext;
+    payload: T;
+  };
+}
+
+
+
+export type QueuejobJob = {
+  id: string; // {"type":"string","required":true,"default":""}
+  processor: string; // {"type":"string","required":true,"default":""}
+  name: string; // {"type":"string","required":true,"default":""}
+  status: string; // {"type":"string","required":true,"default":""}
+  title?: string; // {"type":"string","required":false,"default":""}
+};
+
+export type QueuejobPayload = {
+  [key: string]: any;
+};
+
+export type QueuejobResult = {
+  [key: string]: any;
+};
+
+export type QueuejobError = {
+  status?: number; // {"type":"number","required":false,"default":0}
+  name?: string; // {"type":"string","required":false,"default":""}
+  message?: string; // {"type":"string","required":false,"default":""}
+};
+
+export type Queuejob = {
+  _id?: string; // {"type":"string","required":false,"format":"uuid","default":""}
+  created?: string; // {"type":"string","required":false,"default":""}
+  updated?: string; // {"type":"string","required":false,"default":""}
+  createdBy?: string; // {"type":"string","required":false,"default":""}
+  updatedBy?: string; // {"type":"string","required":false,"default":""}
+  tenantId?: number; // {"type":"number","required":false,"default":1}
+  orgId?: number; // {"type":"number","required":false,"default":1}
+  branchId?: number; // {"type":"number","required":false,"default":1}
+  job: QueuejobJob; //child object
+
+  payload?: QueuejobPayload; //child object
+
+  result?: QueuejobResult; //child object
+
+  error?: QueuejobError; //child object
+};
+
+
+/***************************************** Start Auto Complete *****************************************/
+export type QueuejobAutoComplete = {
+  _id: string;
+  code: string;
+  label: string;
+};
+/****************************************** End Auto Complete ******************************************/

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

@@ -0,0 +1,51 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2024-04-02
+ * Author: Ks Tan
+ */
+import { Module } from '@nestjs/common';
+
+import { SimpleAppAuthModule } from './auth/auth.module';
+import { DocumentNoFormatModule } from './document-no-format/document-no-format.module';
+import { SimpleAppForeignKeyModule } from './foreign-key/foreign-key.module';
+import { SimpleAppLogModule } from './log/log.module';
+import { MaintenanceModule } from './maintenance/maintenance.module';
+import { SimpleAppSoftwarePolicyModule } from './policy/policy.module';
+
+import { SimpleAppMiniAppModule } from './mini-app/mini-app.module';
+import { ProfileModule } from './profile/profile.module';
+import { SimpleAppUserContextModule } from './user-context/user-context.module';
+import { SimpleAppWebhookModule } from './webhook/webhook.module';
+import { AutoIncreamentModule } from './auto-increament/auto-increament.module';
+@Module({
+  imports: [
+    AutoIncreamentModule,
+    SimpleAppAuthModule,
+    DocumentNoFormatModule,
+    SimpleAppForeignKeyModule,
+    SimpleAppLogModule,
+    MaintenanceModule,
+    ProfileModule,
+    SimpleAppUserContextModule,
+    SimpleAppWebhookModule,
+    SimpleAppMiniAppModule,
+    SimpleAppSoftwarePolicyModule,
+  ],
+  controllers: [],
+  providers: [],
+  exports: [
+    AutoIncreamentModule,
+    SimpleAppAuthModule,
+    DocumentNoFormatModule,
+    SimpleAppForeignKeyModule,
+    SimpleAppLogModule,
+    MaintenanceModule,
+    ProfileModule,
+    SimpleAppUserContextModule,
+    SimpleAppWebhookModule,
+    SimpleAppMiniAppModule,
+    SimpleAppSoftwarePolicyModule,
+  ],
+})
+export class SimpleAppCoreFeaturesModule {}

package/templates/nest/src/{simpleapp/generate/commons/robotuser.service.ts.eta → simple-app/.core/features/user-context/robot-user.service.ts.eta}

@@ -1,29 +1,27 @@
-/**
- * This file was automatically generated by simpleapp generator. Every
- * MODIFICATION OVERRIDE BY GENERATEOR
- * last change 2024-03-19
- * Author: Ks Tan
- */
 import { Injectable, Logger } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import { Model } from 'mongoose';
-import { UserContext } from 'src/simpleapp/generate/commons/user.context';
-import { Permission } from 'src/simpleapp/services/perm.service';
-import { User } from 'src/simpleapp/services/user.service';
-import { Appintegration } from 'src/simpleapp/services/appintegration.service';
-import { Miniappinstallation } from '../types';
+import { MiniAppInstallation } from '../../resources/mini-app-installation/mini-app-installation.schema';
+import { Permission } from '../../resources/permission/permission.schema';
+import { User } from '../../resources/user/user.schema';
+import { BaseUserContext } from './user-context.type';
+import { UserContext } from './user.context';
 const Base64URL = require('@darkwolf/base64url');
 @Injectable()
 export class SimpleAppRobotUserService {
   private systemAccessToken: string;
+  private defaultCountry = 'MY';
+  private defaultCurrency = 'MYR';
+  private defaultTimeZone = 'Asia/Kuala_Lumpur';
+  private defaultOffsetMinute = -460;
   private setToken = (token: string) => (this.systemAccessToken = token);
   private getToken = () => this.systemAccessToken;
   private expired: string;
   logger = new Logger();
-  @InjectModel('User') private readonly usermodel: Model<User>;
-  @InjectModel('Permission') private readonly permmodel: Model<Permission>;
-  @InjectModel('Appintegration') private readonly appmodel: Model<Appintegration>;
-  @InjectModel('Miniappinstallation') private readonly miniAppInstallationModel: Model<Miniappinstallation>;
+  @InjectModel('User') private readonly userModel: Model<User>;
+  @InjectModel('Permission') private readonly permModel: Model<Permission>;
+  // @InjectModel('Appintegration') private readonly appmodel: Model<Appintegration>;
+  @InjectModel('MiniAppInstallation') private readonly miniAppInstallationModel: Model<MiniAppInstallation>;
 
   constructor() {
     this.init();
@@ -91,9 +89,22 @@ export class SimpleAppRobotUserService {
     // }
   }
 
+  createDumyAppUser(userContext: BaseUserContext) {
+    const appUser = new UserContext(this.userModel, this.permModel, this.miniAppInstallationModel);
+    const user = userContext
+    const xorg = appUser.generateXOrg(user.tenantId, user.orgId, user.branchId);
+    
+    appUser.setAsStaticUser(user.uid ?? '00000000-0000-0000-0000-000000000000', user.uname ?? 'robot', user.fullName ?? 'Robot', user.email ?? 'robot@a.org', xorg);
+    appUser.setTimeZone(user.timeZone ?? this.defaultTimeZone);
+    appUser.setCountry(user.country ?? this.defaultCountry);
+    appUser.setCurrency(user.currency ?? this.defaultCurrency);
+    appUser.setOffsetMinute(user.offsetMinute ?? this.defaultOffsetMinute);
+    return appUser;
+  }
   prepareAppUser(data: any) {
     // console.log('prepareAppUserprepareAppUser');
-    const appuser = new UserContext(this.usermodel, this.permmodel, this.appmodel, this.miniAppInstallationModel);
+    // this.appmodel,
+    const appuser = new UserContext(this.userModel, this.permModel, this.miniAppInstallationModel);
     appuser.setAsStaticUser('00000000-0000-0000-0000-000000000000', 'robot', 'Robot', 'robot@a.org', Base64URL.encodeText('0-0-0'));
 
     const tenantId = data?.tenantId ?? 0;

package/templates/nest/src/simple-app/.core/features/user-context/user-context.module.ts.eta

@@ -0,0 +1,24 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2024-04-02
+ * Author: Ks Tan
+ */
+import { Module } from '@nestjs/common';
+import { SimpleAppRobotUserService } from './robot-user.service';
+// import { MongooseModule } from '@nestjs/mongoose';
+// import { ProfileService } from './profile.service';
+// import { ProfileController } from './profile.controller';
+import {UserModule} from '../../resources/user/user.module'
+import {PermissionModule} from '../../resources/permission/permission.module'
+import {TenantModule} from '../../resources/tenant/tenant.module'
+import {BranchModule} from '../../resources/branch/branch.module'
+import {OrganizationModule} from '../../resources/organization/organization.module'
+import { MiniAppInstallationModule } from '../../resources/mini-app-installation/mini-app-installation.module';
+@Module({
+  imports: [UserModule,PermissionModule,MiniAppInstallationModule],
+  controllers: [],
+  providers: [SimpleAppRobotUserService],
+  exports: [SimpleAppRobotUserService],
+})
+export class SimpleAppUserContextModule {}

package/templates/nest/src/simple-app/.core/features/user-context/user-context.type.ts.eta

@@ -0,0 +1,15 @@
+  export type BaseUserContext = {    
+      _id?: string;
+      uid?: string;
+      uname?: string;
+      fullName?: string;
+      email?: string;
+      timeZone?: string;
+      currency?: string;
+      country?: string;
+      offsetMinute?: number;
+      tenantId?:number;
+      orgId?:number;
+      branchId?:number;
+
+  };