@simitgroup/simpleapp-generator 1.6.7-m-alpha → 2.0.0-a-alpha

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

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import _ from 'lodash';
+import { MiniAppStatusEnum } from 'src/simple-app/.core/resources/mini-app/mini-app.enum';
+import { PolicyService } from 'src/simple-app/.core/features/policy/policy.service';
+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';
+
+@Injectable()
+export class MiniAppManagerPolicyService {
+  readonly _RELEASED_STATUSES = [MiniAppStatusEnum.PUBLISHED];
+
+  constructor(private readonly policyService: PolicyService) {}
+
+  canInstall(appUser: UserContext) {
+    return this.policyService.can(appUser, Role.MiniAppInstallation_create);
+  }
+
+  canUninstall(appUser: UserContext) {
+    return this.policyService.can(appUser, Role.MiniAppInstallation_update);
+  }
+
+  canUpdateSetting(appUser: UserContext) {
+    return this.policyService.can(appUser, Role.MiniAppInstallation_update);
+  }
+
+  hasFeature(appUser: UserContext) {
+    return this.policyService.hasFeature(appUser, 'miniApp');
+  }
+
+  hasRequiredPlan(appUser: UserContext, miniApp: MiniApp) {
+    const currentPlan = appUser.getPackage();
+    const requiredPlans = miniApp.access.requiredPlans ?? [];
+
+    if (_.isEmpty(requiredPlans)) return true;
+
+    return requiredPlans.includes(currentPlan);
+  }
+
+  isMiniAppRealeased(status: MiniAppStatusEnum) {
+    return this._RELEASED_STATUSES.includes(status);
+  }
+}

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

@@ -0,0 +1,81 @@
+import { Body, Controller, Get, Param, Post, Put } from '@nestjs/common';
+import { ApiTags, ApiBody, ApiResponse, ApiOperation } from '@nestjs/swagger';
+
+import { AppUser } from 'src/simple-app/.core/features/user-context/appuser.decorator';
+import { Roles } from 'src/simple-app/.core/features/auth/role-guard/roles.decorator';
+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 schemas from '../dto';
+import { MiniAppManagerBridgeService } from './mini-app-manager-bridge.service';
+
+
+@ApiTags('MINIAPPMANAGER')
+@Controller('mini-app-manager')
+export class MiniAppManagerController {
+  constructor(private readonly service: MiniAppManagerBridgeService) {}
+
+  @Put('mini-apps/:miniAppCode/install')
+  @Roles(Role.SuperAdmin, Role.SuperUser, Role.User)
+  @ApiResponse({ status: 200, description: 'Install a miniApp', type: schemas.MiniAppInstallation })
+  @ApiOperation({ operationId: 'runInstallMiniApp' })
+  async installMiniApp(@AppUser() appUser: UserContext, @Param('miniAppCode') miniAppCode: string) {
+    const res = await this.service.runInstallMiniApp(appUser, miniAppCode);
+    return res;
+  }
+
+  @Put('mini-apps/:miniAppCode/uninstall')
+  @Roles(Role.SuperAdmin, Role.SuperUser, Role.User)
+  @ApiResponse({ status: 200, description: 'Uninstall a miniApp', type: schemas.MiniAppInstallation })
+  @ApiOperation({ operationId: 'runUninstallMiniApp' })
+  async uninstallMiniApp(@AppUser() appUser: UserContext, @Param('miniAppCode') miniAppCode: string) {
+    const res = await this.service.runUninstallMiniApp(appUser, miniAppCode);
+    return res;
+  }
+
+  @Put('mini-apps/:miniAppCode/update-setting')
+  @Roles(Role.SuperAdmin, Role.SuperUser, Role.User)
+  @ApiBody({ description: 'Request Body', type: schemas.DynamicParam })
+  @ApiResponse({ status: 200, description: 'Update miniApp setting', type: schemas.MiniAppInstallation })
+  @ApiOperation({ operationId: 'runUpdateMiniAppSetting' })
+  async updateMiniAppSetting(@AppUser() appUser: UserContext, @Body() data: schemas.DynamicParam, @Param('miniAppCode') miniAppCode: string) {
+    const res = await this.service.runUpdateMiniAppSetting(appUser, miniAppCode, data);
+    return res;
+  }
+
+  @Get('installed-mini-apps')
+  @Roles(Role.SuperAdmin, Role.SuperUser, Role.User)
+  @ApiResponse({ status: 200, description: 'Get installed miniApps', type: schemas.InstalledMiniAppDetail })
+  @ApiOperation({ operationId: 'runGetInstalledMiniApps' })
+  async getInstalledMiniApps(@AppUser() appUser: UserContext) {
+    const res = await this.service.runGetInstalledMiniApps(appUser);
+    return res;
+  }
+
+  @Get('categorized-mini-apps')
+  @Roles(Role.SuperAdmin, Role.SuperUser, Role.User)
+  @ApiResponse({ status: 200, description: 'Get categorized miniApps', type: schemas.CategorizedMiniAppDetail })
+  @ApiOperation({ operationId: 'runGetCategorizedMiniApps' })
+  async getCategorizedMiniApps(@AppUser() appUser: UserContext) {
+    const res = await this.service.runGetCategorizedMiniApps(appUser);
+    return res;
+  }
+
+  @Get('mini-apps/:miniAppCode')
+  @Roles(Role.SuperAdmin, Role.SuperUser, Role.User)
+  @ApiResponse({ status: 200, description: 'Get miniApp detail', type: schemas.MiniAppDetail })
+  @ApiOperation({ operationId: 'runGetMiniAppDetail' })
+  async getMiniAppDetail(@AppUser() appUser: UserContext, @Param('miniAppCode') miniAppCode: string) {
+    const res = await this.service.runGetMiniAppDetail(appUser, miniAppCode);
+    return res;
+  }
+
+  @Post('system-default-mini-apps-migration')
+  @Roles(Role.Everyone)
+  @ApiResponse({ status: 200, description: 'Migrate system default miniApp.', type: [schemas.MiniApp] })
+  @ApiOperation({ operationId: 'runSystemDefaultMiniAppMigration' })
+  async systemDefaultMiniAppMigration(@AppUser() appUser: UserContext) {
+    const res = await this.service.runSystemDefaultMiniAppMigration(appUser);
+    return res;
+  }
+}

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

@@ -0,0 +1,5 @@
+export enum MiniAppManagerEnvEnum {
+  DEV = 'dev',
+  PROD = 'prod',
+  // SEMI = 'semi',
+}

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

@@ -0,0 +1,24 @@
+export class MiniAppError {
+  static readonly ERR = {
+    NO_FEATURE: "Mini App isn't available in your current plan. Upgrade to unlock this feature.",
+    NOT_FOUND: 'Mini App not found.',
+    NOT_RELEASED: 'Mini App not yet released. Current Status: {status}.',
+    INSTALLATION_NOT_FOUND: 'Mini App is not installed.',
+    ALREADY_INSTALLED: 'Mini App is already installed.',
+    NOT_INSTALLED: 'Mini App is not yet installed.',
+    PLAN_REQUIRED: '"{miniAppName}" requires a higher-tier plan: [{requiredPlans}]. Please upgrade to unlock this feature.',
+    PRIVATE_APP: "This is private app, you don't have permission to perform this action",
+    UNKNOWN_ENV: 'Unknown Env',
+    MINI_APP_CODE_DUPLICATE: 'Duplicated Mini App code',
+    UNDEFINED_DEMO_COMPANY: 'Undefined Demo Company',
+    INVALID_CODE_EMPTY: 'Code Empty',
+    INVALID_CODE_SUFFIX: 'Code name must not end with "_dev".',
+    INVALID_CODE_PATTERN: 'Code name must contain only letters, numbers, and underscores.',
+  };
+
+  static format(message: string, replacements?: Record<string, string>) {
+    if (!replacements) return message;
+
+    return Object.entries(replacements).reduce((msg, [key, value]) => msg.replace(`{${key}}`, value), message);
+  }
+}

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

@@ -0,0 +1,309 @@
+import { UserContext } from 'src/simple-app/.core/features/user-context/user.context';
+import { MiniAppService } from 'src/simple-app/.core/resources/mini-app/mini-app.service';
+import { MiniAppInstallationService } from 'src/simple-app/.core/resources/mini-app-installation/mini-app-installation.service';
+import { MiniAppManagerPolicyService } from './mini-app-manager-policy.service';
+import _ from 'lodash';
+import { BadRequestException, NotFoundException } from '@nestjs/common';
+import { MiniAppError } from './mini-app-manager.error';
+import { MiniAppEnvEnum, MiniAppStatusEnum } from 'src/simple-app/.core/resources/mini-app/mini-app.enum';
+import { DynamicParam,MiniApp,MiniAppInstallation, CategorizedMiniAppDetail, InstalledMiniAppDetail, MiniAppDetail } from '../dto';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+export abstract class MiniAppManagerProcessor {
+  constructor(
+    protected readonly miniAppService: MiniAppService,
+    protected readonly miniAppInstallationService: MiniAppInstallationService,
+    protected readonly policyService: MiniAppManagerPolicyService,
+    @InjectModel('MiniApp')
+    private miniAppDoc: Model<MiniApp>,
+  ) {}
+
+  // ========================================= Abstract =========================================
+
+  abstract runGetInstalledMiniApps(appUser: UserContext): Promise<InstalledMiniAppDetail>;
+  abstract runGetMiniAppDetail(appUser: UserContext, miniApp: MiniApp): Promise<MiniAppDetail>;
+  abstract runGetCategorizedMiniApps(appUser: UserContext): Promise<CategorizedMiniAppDetail>;
+  abstract runInstallMiniApp(appUser: UserContext, miniApp: MiniApp): Promise<MiniAppInstallation>;
+  abstract runUninstallMiniApp(appUser: UserContext, miniApp: MiniApp): Promise<MiniAppInstallation>;
+  abstract runUpdateMiniAppSetting(appUser: UserContext, miniApp: MiniApp, data: DynamicParam): Promise<MiniAppInstallation>;
+
+  // ========================================== Action ==========================================
+
+  protected async findInstalledMiniAppsDetail(appUser: UserContext) {
+    const permissions = this.resolveMiniAppPermissions(appUser);
+    const { miniAppInstallations, installedMiniAppIdArr } = await this.findInstalledMiniAppIds(appUser);
+    const miniApps = await this.miniAppService.search(appUser, {
+      _id: { $in: installedMiniAppIdArr },
+    });
+
+    const installedMiniApps = miniAppInstallations
+      .map((installation) => {
+        const miniApp = miniApps.find((miniApp) => miniApp._id === installation.miniApp._id);
+        if (!miniApp) {
+          return null;
+        }
+
+        return this.formatMiniAppDetail(appUser, miniApp, installation);
+      })
+      .filter(Boolean);
+
+    return { installedMiniApps: installedMiniApps, permissions };
+  }
+
+  protected async findMiniAppDetail(appUser: UserContext, miniApp: MiniApp) {
+    const miniAppInstallation = await this.findMiniAppInstallation(appUser, miniApp.code);
+    return this.formatMiniAppDetail(appUser, miniApp, miniAppInstallation);
+  }
+
+  protected categorizedMiniApps(appUser: UserContext, miniApps: MiniApp[]): CategorizedMiniAppDetail {
+    const result = {
+      upcomingMiniApps: [],
+      availableMiniApps: [],
+    };
+
+    miniApps.forEach((miniApp) => {
+      if (miniApp.status === MiniAppStatusEnum.UPCOMING) {
+        result.upcomingMiniApps.push(this.formatMiniAppDetail(appUser, miniApp));
+      } else {
+        if (miniApp.access.visibility === 'private') {
+          if (!(miniApp.access.allowEmails ?? []).includes(appUser.getEmail())) {
+            return;
+          }
+        }
+
+        result.availableMiniApps.push(this.formatMiniAppDetail(appUser, miniApp));
+      }
+    });
+
+    return result;
+  }
+
+  protected async install(appUser: UserContext, miniApp: MiniApp) {
+    const miniAppInstallation = await this.findMiniAppInstallation(appUser, miniApp.code);
+    if (!miniAppInstallation) {
+      // Not Found Installation Record, Create New One
+      return await this.createMiniAppInstallation(appUser, miniApp);
+    }
+
+    if (miniAppInstallation.isActive) {
+      // Found Installation Record, And It Is Activated
+      const msg = MiniAppError.format(MiniAppError.ERR.ALREADY_INSTALLED);
+      throw new BadRequestException(msg);
+    }
+
+    // Found Installation Record, And It Is Deactive, Reactivate It
+    return await this.reactivateInstalledMiniApp(appUser, miniAppInstallation);
+  }
+
+  protected async uninstall(appUser: UserContext, miniApp: MiniApp) {
+    const miniAppInstallation = await this.findIsMiniAppInstalledOrFail(appUser, miniApp.code);
+    return await this.deactiveInstalledMiniApp(appUser, miniAppInstallation);
+  }
+
+  protected async updateSetting(appUser: UserContext, miniApp: MiniApp, data: DynamicParam) {
+    const miniAppInstallation = await this.findIsMiniAppInstalledOrFail(appUser, miniApp.code);
+    return await this.setMiniAppInstallationSetting(appUser, miniAppInstallation, data);
+  }
+
+  // ========================================== Finder ==========================================
+
+  protected async findMiniAppInstallation(appUser: UserContext, miniAppCode: string): Promise<MiniAppInstallation | undefined> {
+    const miniAppInstallations = await this.miniAppInstallationService.search(appUser, {
+      'miniApp.code': miniAppCode,
+    });
+
+    return miniAppInstallations?.[0];
+  }
+
+  protected async findMiniAppInstallations(appUser: UserContext) {
+    const miniAppInstallations = await this.miniAppInstallationService.search(
+      appUser,
+      {
+        isActive: true,
+      },
+      undefined,
+      {
+        seqNo: 1,
+      },
+    );
+
+    return miniAppInstallations;
+  }
+
+  protected async findMiniAppInstallationOrFail(appUser: UserContext, miniAppCode: string) {
+    const miniAppInstallation = await this.findMiniAppInstallation(appUser, miniAppCode);
+    if (!miniAppInstallation) {
+      const msg = MiniAppError.format(MiniAppError.ERR.NOT_INSTALLED);
+      throw new NotFoundException(msg);
+    }
+
+    return miniAppInstallation;
+  }
+
+  protected async findIsMiniAppInstalledOrFail(appUser: UserContext, miniAppCode: string) {
+    const miniAppInstallation = await this.findMiniAppInstallationOrFail(appUser, miniAppCode);
+    if (!miniAppInstallation.isActive) {
+      // Already inactive, previously already uninstall
+      const msg = MiniAppError.format(MiniAppError.ERR.NOT_INSTALLED);
+      throw new NotFoundException(msg);
+    }
+
+    return miniAppInstallation;
+  }
+
+  protected async findInstalledMiniAppIds(appUser: UserContext) {
+    const miniAppInstallations = await this.findMiniAppInstallations(appUser);
+    const installedMiniAppIdArr = miniAppInstallations.map((inst) => inst.miniApp._id);
+
+    return {
+      miniAppInstallations,
+      installedMiniAppIdArr,
+    };
+  }
+
+  // ========================================== Assert ==========================================
+
+  protected assertHasMiniAppFeature(appUser: UserContext) {
+    if (!this.policyService.hasFeature(appUser)) {
+      const msg = MiniAppError.format(MiniAppError.ERR.NO_FEATURE);
+      throw new BadRequestException(msg);
+    }
+  }
+
+  protected assertIsMiniAppReleased(miniApp: MiniApp) {
+    if (!this.policyService.isMiniAppRealeased(miniApp.status as MiniAppStatusEnum)) {
+      const msg = MiniAppError.format(MiniAppError.ERR.NOT_RELEASED, { status: miniApp.status });
+      throw new BadRequestException(msg);
+    }
+  }
+
+  protected assertHasRequiredPlan(appUser: UserContext, miniApp: MiniApp) {
+    if (!this.policyService.hasRequiredPlan(appUser, miniApp)) {
+      const msg = MiniAppError.format(MiniAppError.ERR.PLAN_REQUIRED, { miniAppName: miniApp.name, requiredPlans: miniApp.access.requiredPlans.join(', ') });
+      throw new BadRequestException(msg);
+    }
+  }
+
+  protected assertPrivateAppPermission(appUser: UserContext, miniApp: MiniApp) {
+    if (miniApp.access.visibility === 'private') {
+      if (!(miniApp.access.allowEmails ?? []).includes(appUser.getEmail())) {
+        const msg = MiniAppError.format(MiniAppError.ERR.PRIVATE_APP);
+        throw new BadRequestException(msg);
+      }
+    }
+  }
+
+  protected async assertMiniAppCodeUnique(appUser: UserContext, miniAppCode: string) {
+    const miniApp = await this.miniAppDoc.findOne({
+      code: miniAppCode,
+    });
+
+    if (miniApp) {
+      const msg = MiniAppError.format(MiniAppError.ERR.MINI_APP_CODE_DUPLICATE);
+      throw new BadRequestException(msg);
+    }
+  }
+
+  protected assertMiniAppCodePattern(miniAppCode: string) {
+    if (_.isEmpty(miniAppCode)) {
+      const msg = MiniAppError.format(MiniAppError.ERR.INVALID_CODE_EMPTY);
+      throw new BadRequestException(msg);
+    }
+
+    if (miniAppCode.endsWith('_dev')) {
+      const msg = MiniAppError.format(MiniAppError.ERR.INVALID_CODE_SUFFIX);
+      throw new BadRequestException(msg);
+    }
+
+    const validPattern = /^[a-zA-Z0-9_]+$/;
+    if (!validPattern.test(miniAppCode)) {
+      const msg = MiniAppError.format(MiniAppError.ERR.INVALID_CODE_PATTERN);
+      throw new BadRequestException(msg);
+    }
+  }
+
+  // ===================================== Update Collection ====================================
+
+  protected async createMiniAppInstallation(appUser: UserContext, miniApp: MiniApp) {
+    return await this.miniAppInstallationService.create(appUser, {
+      apiKey: crypto.randomUUID(),
+      isActive: true,
+      miniApp: {
+        _id: miniApp._id,
+        code: miniApp.code,
+        label: miniApp.name,
+        env: miniApp.env,
+        developerPortalAppId: miniApp.developerPortal.appId,
+      },
+      miniApiUser: this.buildMiniApiUserPayload(appUser),
+      settings: {},
+    });
+  }
+
+  protected async setMiniAppInstallationActiveStatus(appUser: UserContext, miniAppInstallation: MiniAppInstallation, isActive: boolean) {
+    return await this.miniAppInstallationService.findIdThenPatch(appUser, miniAppInstallation._id, {
+      isActive,
+    } as MiniAppInstallation);
+  }
+
+  protected async setMiniAppInstallationSetting(appUser: UserContext, miniAppInstallation: MiniAppInstallation, data: DynamicParam) {
+    return await this.miniAppInstallationService.findIdThenPatch(appUser, miniAppInstallation._id, {
+      settings: data,
+    } as MiniAppInstallation);
+  }
+
+  // ========================================== Format ==========================================
+
+  protected formatMiniAppDetail(appUser: UserContext, miniApp: MiniApp, installation?: MiniAppInstallation) {
+    const enabled = miniApp.integration.enabled;
+    if (!enabled.customField) {
+      miniApp.integration.customField = undefined;
+    }
+
+    if (!enabled.customPage) {
+      miniApp.integration.customPage = undefined;
+    }
+
+    // @ts-expect-error Got toObject() function
+    const miniAppObj = miniApp.toObject();
+
+    return {
+      ...miniAppObj,
+      hasRequiredPlan: this.policyService.hasRequiredPlan(appUser, miniApp),
+      // @ts-expect-error Got toObject() function
+      miniAppInstallation: installation ? installation.toObject() : undefined,
+    };
+  }
+
+  // =========================================== Other ==========================================
+
+  protected async reactivateInstalledMiniApp(appUser: UserContext, miniAppInstallation: MiniAppInstallation) {
+    return await this.miniAppInstallationService.findIdThenPatch(appUser, miniAppInstallation._id, {
+      isActive: true,
+      miniApiUser: this.buildMiniApiUserPayload(appUser),
+    } as MiniAppInstallation);
+  }
+
+  protected async deactiveInstalledMiniApp(appUser: UserContext, miniAppInstallation: MiniAppInstallation) {
+    return this.setMiniAppInstallationActiveStatus(appUser, miniAppInstallation, false);
+  }
+
+  protected resolveMiniAppPermissions(appUser: UserContext) {
+    return {
+      hasMiniAppFeature: this.policyService.hasFeature(appUser),
+      canInstall: this.policyService.canInstall(appUser),
+      canUninstall: this.policyService.canUninstall(appUser),
+      canUpdateSetting: this.policyService.canUpdateSetting(appUser),
+    };
+  }
+
+  protected buildMiniApiUserPayload(appUser: UserContext) {
+    return {
+      _id: appUser.getId(),
+      uid: appUser.getUid(),
+      name: appUser.getFullname(),
+      email: appUser.getEmail(),
+    };
+  }
+}