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

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

@@ -0,0 +1,94 @@
+import { Injectable } from '@nestjs/common';
+import { Branch, Miniapp, Miniappinstallation } from 'src/simpleapp/generate/types';
+import _ from 'lodash';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { UserContext } from 'src/simpleapp/generate/commons/user.context';
+import { MiniappEnvEnum } from 'src/enums/enums.generate';
+
+@Injectable()
+export class DeveloperPortalService {
+  constructor(
+    @InjectModel('Miniapp')
+    protected miniAppDoc: Model<Miniapp>,
+
+    @InjectModel('Miniappinstallation')
+    protected miniAppInstallationDoc: Model<Miniappinstallation>,
+
+    @InjectModel('Branch')
+    protected branchDoc: Model<Branch>,
+  ) {}
+
+  async getDemoCompany(developerPortalAppId: string) {
+    // Only dev got development.demoXOrg field
+    const miniApp = await this.miniAppDoc.findOne({
+      'developerPortal.appId': developerPortalAppId,
+      env: MiniappEnvEnum.DEV,
+    });
+    if (miniApp && !_.isEmpty(miniApp?.development?.demoXOrg)) {
+      return miniApp.development.demoXOrg;
+    }
+
+    return process.env.DEMO_COMPANY_XORG;
+  }
+
+  async getInstalledMiniAppXOrgs(appUser: UserContext, developerPortalAppId: string) {
+    const demoXOrg = await this.getDemoCompany(developerPortalAppId);
+
+    // Only get env === prod one
+    const miniAppInstallations = await this.miniAppInstallationDoc.find({
+      'miniApp.developerPortalAppId': developerPortalAppId,
+      'miniApp.env': MiniappEnvEnum.PROD,
+    });
+
+    if (!miniAppInstallations || _.isEmpty(miniAppInstallations)) {
+      return {
+        demoXOrg,
+        installedXOrgs: [],
+      };
+    }
+
+    // Step 1: Extract unique composite keys for branch lookup
+    const branchKeyList = miniAppInstallations.map((install) => ({
+      tenantId: install.tenantId,
+      orgId: install.orgId,
+      branchId: install.branchId,
+    }));
+
+    // Step 2: Build $or filter for batch querying branches
+    const branchFilter = {
+      $or: branchKeyList.map(({ tenantId, orgId, branchId }) => ({
+        tenantId,
+        orgId,
+        branchId,
+      })),
+    };
+
+    // Step 3: Run one query to get all branches
+    const allBranches = await this.branchDoc.find(branchFilter);
+
+    // Step 4: Build a lookup map: `${tenantId}-${orgId}-${branchId}` → branch
+    const branchMap = new Map<string, Branch>();
+    for (const branch of allBranches) {
+      const key = `${branch.tenantId}-${branch.orgId}-${branch.branchId}`;
+      branchMap.set(key, branch);
+    }
+
+    // Step 5: Compose result
+    const installedXOrgs = miniAppInstallations.map((install) => {
+      const key = `${install.tenantId}-${install.orgId}-${install.branchId}`;
+      const branch = branchMap.get(key);
+
+      return {
+        branchCode: branch?.branchCode,
+        branchName: branch?.branchName,
+        xOrg: appUser.generateXOrg(install.tenantId, install.orgId, install.branchId),
+      };
+    });
+
+    return {
+      demoXOrg,
+      installedXOrgs,
+    };
+  }
+}

package/templates/nest/src/simple-app/.core/features/mini-app/developer-portal/dto/developer-portal-create-app.dto.ts.eta

@@ -0,0 +1,22 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { ApiProperty } from '@nestjs/swagger';
+import { MiniappAuthor } from 'src/simpleapp/generate/apischemas';
+
+@ObjectType()
+export class DeveloperPortalCreateAppDto {
+  @Field()
+  @ApiProperty({ type: 'string', required: true, default: '' })
+  code: string;
+
+  @Field()
+  @ApiProperty({ type: 'string', required: true, default: '' })
+  name: string;
+
+  @Field()
+  @ApiProperty({ type: 'string', required: true, default: '' })
+  version: string;
+
+  @Field()
+  @ApiProperty({ type: MiniappAuthor, required: true, default: '' })
+  author: MiniappAuthor;
+}

package/templates/nest/src/simple-app/.core/features/mini-app/dto/imports.ts.eta

@@ -0,0 +1,2 @@
+export * from '../../../resources/mini-app-installation/mini-app-installation.schema';
+export * from '../../../resources/mini-app/mini-app.schema';

package/templates/nest/src/simple-app/.core/features/mini-app/dto/index.ts.eta

@@ -0,0 +1,2 @@
+export * from './mini-app';
+export * from './imports'

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

@@ -0,0 +1,55 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { ApiProperty } from '@nestjs/swagger';
+import { MiniApp, MiniAppInstallation } from './imports';
+
+@ObjectType()
+export class MiniAppDetailPermission {
+  @Field()
+  @ApiProperty({ type: 'boolean', required: true, default: false })
+  hasMiniAppFeature: boolean;
+
+  @Field()
+  @ApiProperty({ type: 'boolean', required: true, default: false })
+  canInstall: boolean;
+
+  @Field()
+  @ApiProperty({ type: 'boolean', required: true, default: false })
+  canUninstall: boolean;
+
+  @Field()
+  @ApiProperty({ type: 'boolean', required: true, default: false })
+  canUpdateSetting: boolean;
+}
+
+@ObjectType()
+export class MiniAppDetail extends MiniApp {
+  @Field(() => MiniAppInstallation)
+  @ApiProperty({ type: () => MiniAppInstallation, required: false })
+  miniAppInstallation?: MiniAppInstallation;
+
+  @Field()
+  @ApiProperty({ type: 'boolean' })
+  hasRequiredPlan: boolean;
+}
+
+@ObjectType()
+export class CategorizedMiniAppDetail {
+  @Field(() => [MiniAppDetail])
+  @ApiProperty({ type: () => [MiniAppDetail] })
+  upcomingMiniApps: MiniAppDetail[];
+
+  @Field(() => [MiniAppDetail])
+  @ApiProperty({ type: () => [MiniAppDetail] })
+  availableMiniApps: MiniAppDetail[];
+}
+
+@ObjectType()
+export class InstalledMiniAppDetail {
+  @Field(() => MiniAppDetailPermission)
+  @ApiProperty({ type: () => MiniAppDetailPermission, required: true })
+  permissions: MiniAppDetailPermission;
+
+  @Field(() => [MiniAppDetail])
+  @ApiProperty({ type: () => [MiniAppDetail] })
+  installedMiniApps: MiniAppDetail[];
+}

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

@@ -0,0 +1,162 @@
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { UserContext } from 'src/simple-app/.core/features/user-context/user.context';
+import _ from 'lodash';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { MiniApp , DynamicParam, MiniAppInstallation} from '../dto';
+import { MiniAppError } from './mini-app-manager.error';
+import { MiniAppManagerEnvEnum } from './mini-app-manager.enum';
+import { MiniAppManagerEnvDevelopmentService } from './mini-app-manager-env-development.service';
+import { MiniAppManagerEnvProductionService } from './mini-app-manager-env-production.service';
+import { getEnvironment } from '../utils/mini-app.util';
+// import { DEFAULT_MINI_APPS } from 'src/data/miniApps';
+
+@Injectable()
+export class MiniAppManagerBridgeService {
+  constructor(
+    private readonly devService: MiniAppManagerEnvDevelopmentService,
+    private readonly prodService: MiniAppManagerEnvProductionService,
+
+    @InjectModel('MiniApp') private readonly miniAppModel: Model<MiniApp>,
+    @InjectModel('MiniAppInstallation') private miniAppInstallationModel: Model<MiniAppInstallation>,
+  ) {}
+
+  private readonly serviceMap: Record<MiniAppManagerEnvEnum, MiniAppManagerEnvDevelopmentService | MiniAppManagerEnvProductionService> = {
+    [MiniAppManagerEnvEnum.DEV]: this.devService,
+    [MiniAppManagerEnvEnum.PROD]: this.prodService,
+  };
+
+  private async findMiniAppOrFail(appUser: UserContext, miniAppCode: string) {
+    const miniApp = await this.miniAppModel.findOne({
+      code: miniAppCode,
+    });
+
+    if (_.isEmpty(miniApp)) {
+      const msg = MiniAppError.format(MiniAppError.ERR.NOT_FOUND);
+      throw new NotFoundException(msg);
+    }
+
+    return miniApp;
+  }
+
+  private async resolveContext(appUser: UserContext) {
+    const env = getEnvironment(appUser);
+
+    const service = this.getService(env);
+
+    return {
+      env,
+      service,
+    };
+  }
+
+  private async resolveContextWithApp(appUser: UserContext, miniAppCode: string) {
+    const env = getEnvironment(appUser);
+    const miniApp = await this.findMiniAppOrFail(appUser, miniAppCode);
+
+    const service = this.getService(env);
+
+    return {
+      miniApp,
+      env,
+      service,
+    };
+  }
+
+  private getService(env: MiniAppManagerEnvEnum): MiniAppManagerEnvDevelopmentService | MiniAppManagerEnvProductionService {
+    const service = this.serviceMap[env];
+    if (!service) {
+      const msg = MiniAppError.format(MiniAppError.ERR.UNKNOWN_ENV);
+      throw new BadRequestException(msg);
+    }
+
+    return service;
+  }
+
+  async runGetInstalledMiniApps(appUser: UserContext) {
+    const { service } = await this.resolveContext(appUser);
+    return await service.runGetInstalledMiniApps(appUser);
+  }
+
+  async runGetCategorizedMiniApps(appUser: UserContext) {
+    const { service } = await this.resolveContext(appUser);
+    return await service.runGetCategorizedMiniApps(appUser);
+  }
+
+  async runGetMiniAppDetail(appUser: UserContext, miniAppCode: string) {
+    const { miniApp, service } = await this.resolveContextWithApp(appUser, miniAppCode);
+    return await service.runGetMiniAppDetail(appUser, miniApp);
+  }
+
+  async runInstallMiniApp(appUser: UserContext, miniAppCode: string) {
+    const { miniApp, service } = await this.resolveContextWithApp(appUser, miniAppCode);
+    return await service.runInstallMiniApp(appUser, miniApp);
+  }
+
+  async runUninstallMiniApp(appUser: UserContext, miniAppCode: string) {
+    const { miniApp, service } = await this.resolveContextWithApp(appUser, miniAppCode);
+    return await service.runUninstallMiniApp(appUser, miniApp);
+  }
+
+  async runUpdateMiniAppSetting(appUser: UserContext, miniAppCode: string, data: DynamicParam) {
+    const { miniApp, service } = await this.resolveContextWithApp(appUser, miniAppCode);
+    return await service.runUpdateMiniAppSetting(appUser, miniApp, data);
+  }
+
+  async runSystemDefaultMiniAppMigration(appUser: UserContext) {
+    // Step 1: Normalize codes with underscores
+    // const renameMap: Record<string, string> = {
+    //   'simbiz-accounting': 'simbiz_accounting',
+    //   'e-invoice': 'e_invoice',
+    // };
+
+    // for (const [oldCode, newCode] of Object.entries(renameMap)) {
+    //   await this.miniAppModel.updateOne({ code: oldCode }, { $set: { code: newCode } });
+    // }
+
+    // // Step 2: Remove unused mini apps
+    // const allowedCodes = ['simbiz_accounting', 'e_invoice', 'webhook', 'mcplus'];
+    // await this.miniAppModel.deleteMany({ code: { $nin: allowedCodes } });
+
+    // // Step 3: Update default data for each mini app
+    // const defaultMap: Record<string, any> = {
+    //   simbiz_accounting: DEFAULT_MINI_APPS.simbizAccounting,
+    //   e_invoice: DEFAULT_MINI_APPS.eInvoice,
+    //   webhook: DEFAULT_MINI_APPS.webhook,
+    //   mcplus: DEFAULT_MINI_APPS.mcplus,
+    // };
+
+    // for (const [code, defaults] of Object.entries(defaultMap)) {
+    //   await this.miniAppModel.updateOne({ code }, defaults);
+    // }
+
+    // // Step 4: Fix mini app installations
+    // const savePromises = [];
+    // const miniAppInstallations = await this.miniAppInstallationModel.find();
+
+    // for (const installation of miniAppInstallations) {
+    //   if (installation.miniApp.code === 'simbiz-accounting') {
+    //     installation.miniApp.code = 'simbiz_accounting';
+    //     installation.miniApp.developerPortalAppId = DEFAULT_MINI_APPS.simbizAccounting.developerPortal.appId;
+    //   } else if (installation.miniApp.code === 'e-invoice') {
+    //     installation.miniApp.code = 'e_invoice';
+    //     installation.miniApp.developerPortalAppId = DEFAULT_MINI_APPS.eInvoice.developerPortal.appId;
+    //   } else if (installation.miniApp.code === 'webhook') {
+    //     installation.miniApp.code = 'webhook';
+    //     installation.miniApp.developerPortalAppId = DEFAULT_MINI_APPS.webhook.developerPortal.appId;
+    //   } else if (installation.miniApp.code === 'mcplus') {
+    //     installation.miniApp.code = 'mcplus';
+    //     installation.miniApp.developerPortalAppId = DEFAULT_MINI_APPS.mcplus.developerPortal.appId;
+    //   }
+
+    //   installation.miniApp.env = 'prod';
+    //   installation.markModified('miniApp');
+
+    //   savePromises.push(installation.save());
+    // }
+
+    // await Promise.all(savePromises);
+
+    return await this.miniAppModel.find();
+  }
+}

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

@@ -0,0 +1,140 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+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 { UserContext } from 'src/simple-app/.core/features/user-context/user.context';
+import { MiniAppManagerProcessor } from './mini-app-manager.processor';
+import { DynamicParam,MiniApp ,CategorizedMiniAppDetail, InstalledMiniAppDetail, MiniAppDetail } from '../dto';
+import { MiniAppEnvEnum, MiniAppStatusEnum } from 'src/simple-app/.core/resources/mini-app/mini-app.enum';
+import { Model } from 'mongoose';
+import { MiniAppManagerEnvEnum } from './mini-app-manager.enum';
+import _ from 'lodash';
+
+@Injectable()
+export class MiniAppManagerEnvDevelopmentService extends MiniAppManagerProcessor {
+  constructor(miniAppService: MiniAppService, miniAppInstallationService: MiniAppInstallationService, policyService: MiniAppManagerPolicyService, miniAppDoc: Model<MiniApp>) {
+    super(miniAppService, miniAppInstallationService, policyService, miniAppDoc);
+  }
+
+  async runGetInstalledMiniApps(appUser: UserContext): Promise<InstalledMiniAppDetail> {
+    return await this.findInstalledMiniAppsDetail(appUser);
+  }
+
+  async runGetCategorizedMiniApps(appUser: UserContext): Promise<CategorizedMiniAppDetail> {
+    const { installedMiniAppIdArr } = await this.findInstalledMiniAppIds(appUser);
+
+    const filter = {
+      _id: { $nin: installedMiniAppIdArr },
+      env: MiniAppEnvEnum.DEV,
+      status: {
+        $in: [MiniAppStatusEnum.DRAFT],
+      },
+    };
+
+    const miniApps = await this.miniAppService.search(appUser, filter);
+    return this.categorizedMiniApps(appUser, miniApps);
+  }
+
+  async runGetMiniAppDetail(appUser: UserContext, miniApp: MiniApp): Promise<MiniAppDetail> {
+    this.assertEnvironment(appUser, miniApp);
+    this.assertPrivateAppPermission(appUser, miniApp);
+
+    return await this.findMiniAppDetail(appUser, miniApp);
+  }
+
+  async runInstallMiniApp(appUser: UserContext, miniApp: MiniApp) {
+    this.assertEnvironment(appUser, miniApp);
+    this.assertHasMiniAppFeature(appUser);
+    this.assertPrivateAppPermission(appUser, miniApp);
+    this.assertHasRequiredPlan(appUser, miniApp);
+    // this.assertIsMiniAppReleased(miniApp);
+
+    return await this.install(appUser, miniApp);
+  }
+
+  async runUninstallMiniApp(appUser: UserContext, miniApp: MiniApp) {
+    this.assertHasMiniAppFeature(appUser);
+
+    return await this.uninstall(appUser, miniApp);
+  }
+
+  async runUpdateMiniAppSetting(appUser: UserContext, miniApp: MiniApp, data: DynamicParam) {
+    this.assertHasMiniAppFeature(appUser);
+    this.assertHasRequiredPlan(appUser, miniApp);
+    // this.assertIsMiniAppReleased(miniApp);
+
+    return await this.updateSetting(appUser, miniApp, data);
+  }
+
+  async createMiniApp(appUser: UserContext, developerPortalAppId: string, dto: MiniApp) {
+    // Validate Original Code Instead Of Processed One, Because Will Check End With ('_dev')
+    this.assertMiniAppCodePattern(dto.code);
+
+    const env = MiniAppManagerEnvEnum.DEV;
+    const miniAppCode = dto.code + '_dev';
+    await this.assertMiniAppCodeUnique(appUser, miniAppCode);
+
+    const payload: MiniApp = {
+      code: miniAppCode,
+      name: dto.name,
+      env: env,
+      version: dto.version,
+      description: '',
+      logo: '',
+      tags: dto.tags,
+      pricing: 0,
+      status: MiniAppStatusEnum.DRAFT,
+      author: dto.author,
+      access: {
+        visibility: 'private',
+        allowEmails: [dto.author.email],
+        requiredPlans: [],
+      },
+      developerPortal: {
+        appId: developerPortalAppId,
+      },
+      intro: {
+        description: '',
+        previewImages: [],
+        features: [],
+      },
+      integration: {
+        enabled: {
+          miniApi: false,
+          customField: false,
+          customPage: false,
+        },
+      },
+    };
+
+    return await this.miniAppService.create(appUser, payload);
+  }
+
+  async updateMiniApp(appUser: UserContext, miniApp: MiniApp, dto: MiniApp) {
+    const payload = {
+      ...miniApp,
+      name: dto.name,
+      version: dto.version,
+      description: dto.description,
+      logo: dto.logo,
+      tags: dto.tags,
+      pricing: dto.pricing,
+      author: dto.author,
+      access: {
+        visibility: 'private',
+        allowEmails: [dto.author.email],
+        requiredPlans: [],
+      },
+      intro: dto.intro,
+      integration: dto.integration,
+    };
+
+    return await this.miniAppService.findIdThenUpdate(appUser, miniApp._id, payload);
+  }
+
+  protected assertEnvironment(appUser: UserContext, miniApp: MiniApp) {
+    if (miniApp.env !== MiniAppManagerEnvEnum.DEV) {
+      throw new BadRequestException('Cannot process production app in dev env');
+    }
+  }
+}

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

@@ -0,0 +1,125 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+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 { UserContext } from 'src/simple-app/.core/features/user-context/user.context';
+import { MiniAppManagerProcessor } from './mini-app-manager.processor';
+import { DynamicParam,MiniApp ,CategorizedMiniAppDetail, InstalledMiniAppDetail, MiniAppDetail } from '../dto';
+import { MiniAppEnvEnum, MiniAppStatusEnum } from 'src/simple-app/.core/resources/mini-app/mini-app.enum';
+import { Model } from 'mongoose';
+import { MiniAppManagerEnvEnum } from './mini-app-manager.enum';
+import _ from 'lodash';
+
+@Injectable()
+export class MiniAppManagerEnvProductionService extends MiniAppManagerProcessor {
+  constructor(miniAppService: MiniAppService, miniAppInstallationService: MiniAppInstallationService, policyService: MiniAppManagerPolicyService, miniAppDoc: Model<MiniApp>) {
+    super(miniAppService, miniAppInstallationService, policyService, miniAppDoc);
+  }
+
+  async runGetInstalledMiniApps(appUser: UserContext): Promise<InstalledMiniAppDetail> {
+    return await this.findInstalledMiniAppsDetail(appUser);
+  }
+
+  async runGetCategorizedMiniApps(appUser: UserContext): Promise<CategorizedMiniAppDetail> {
+    const { installedMiniAppIdArr } = await this.findInstalledMiniAppIds(appUser);
+
+    const filter = {
+      _id: { $nin: installedMiniAppIdArr },
+      env: MiniAppEnvEnum.PROD,
+      status: {
+        $in: [MiniAppStatusEnum.PUBLISHED, MiniAppStatusEnum.UPCOMING, MiniAppStatusEnum.BETA],
+      },
+    };
+
+    const miniApps = await this.miniAppService.search(appUser, filter);
+    return this.categorizedMiniApps(appUser, miniApps);
+  }
+
+  async runGetMiniAppDetail(appUser: UserContext, miniApp: MiniApp): Promise<MiniAppDetail> {
+    this.assertEnvironment(appUser, miniApp);
+    this.assertPrivateAppPermission(appUser, miniApp);
+
+    return await this.findMiniAppDetail(appUser, miniApp);
+  }
+
+  async runInstallMiniApp(appUser: UserContext, miniApp: MiniApp) {
+    this.assertEnvironment(appUser, miniApp);
+    this.assertHasMiniAppFeature(appUser);
+    this.assertPrivateAppPermission(appUser, miniApp);
+    this.assertHasRequiredPlan(appUser, miniApp);
+    this.assertIsMiniAppReleased(miniApp);
+
+    return await this.install(appUser, miniApp);
+  }
+
+  async runUninstallMiniApp(appUser: UserContext, miniApp: MiniApp) {
+    this.assertHasMiniAppFeature(appUser);
+
+    return await this.uninstall(appUser, miniApp);
+  }
+
+  async runUpdateMiniAppSetting(appUser: UserContext, miniApp: MiniApp, data: DynamicParam) {
+    this.assertHasMiniAppFeature(appUser);
+    this.assertHasRequiredPlan(appUser, miniApp);
+    this.assertIsMiniAppReleased(miniApp);
+
+    return await this.updateSetting(appUser, miniApp, data);
+  }
+
+  async createMiniApp(appUser: UserContext, developerPortalAppId: string, dto: MiniApp) {
+    this.assertMiniAppCodePattern(dto.code);
+    await this.assertMiniAppCodeUnique(appUser, dto.code);
+
+    const env = MiniAppManagerEnvEnum.PROD;
+    const payload = {
+      code: dto.code,
+      name: dto.name,
+      env: env,
+      version: dto.version,
+      description: dto.description,
+      logo: dto.logo,
+      tags: dto.tags,
+      pricing: 0,
+      status: MiniAppStatusEnum.PUBLISHED,
+      author: dto.author,
+      access: dto.access,
+      developerPortal: {
+        appId: developerPortalAppId,
+      },
+      intro: dto.intro,
+      integration: dto.integration,
+    };
+
+    return await this.miniAppService.create(appUser, payload);
+  }
+
+  async updateMiniApp(appUser: UserContext, miniApp: MiniApp, dto: MiniApp) {
+    const payload = {
+      ...miniApp,
+      name: dto.name,
+      version: dto.version,
+      description: dto.description,
+      logo: dto.logo,
+      tags: dto.tags,
+      pricing: dto.pricing,
+      author: dto.author,
+      access: dto.access,
+      intro: dto.intro,
+      integration: dto.integration,
+    };
+
+    return await this.miniAppService.findIdThenUpdate(appUser, miniApp._id, payload);
+  }
+
+  protected assertEnvironment(appUser: UserContext, miniApp: MiniApp) {
+    if (miniApp.env !== MiniAppManagerEnvEnum.PROD) {
+      if (!_.isEmpty(miniApp?.development?.demoXOrg)) {
+        if (miniApp.development.demoXOrg === appUser.getXOrg()) {
+          return true;
+        }
+      }
+
+      throw new BadRequestException('Cannot process dev app in prod env');
+    }
+  }
+}

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);
+  }
+}