@erxes/api-shared 0.0.0-stage → 3.2.19-1

package/src/utils/saas/saas-mongo-connection.ts

@@ -0,0 +1,595 @@
+import mongoose from 'mongoose';
+import { getEnv } from '../utils';
+import {
+  saasAddonSchema,
+  saasBundleSchema,
+  saasOrganizationPlanHistorySchema,
+  endPointSchema,
+  experiencesSchema,
+  saasInstallationSchema,
+  saasOrganizationsSchema,
+  saasPluginSchema,
+  saasPromoCodeSchema,
+  saasUserSchema,
+} from './definition';
+import {
+  IOrganization,
+  ISaasAddon,
+  ISaasBundle,
+  ISaasHelpCenterDomain,
+  ISaasOrganizationPlanHistory,
+} from './types';
+import { redis } from '../redis';
+import { mongooseConnectionOptions } from '../mongo';
+
+export let coreModelOrganizations: any;
+export let coreModelAddons: any;
+export let coreModelBundles: any;
+export let coreModelInstallations: any;
+export let coreModelUsers: any;
+export let coreModelEndpoints: any;
+export let coreModelPromoCodes: any;
+export let coreModelPlugins: any;
+export let coreModelExperiences: any;
+export let coreModelOrganizationPlanHistories: mongoose.Model<ISaasOrganizationPlanHistory>;
+
+export const getSaasCoreConnection = async (): Promise<void> => {
+  if (coreModelOrganizations) {
+    return;
+  }
+
+  const CORE_MONGO_URL = getEnv({ name: 'CORE_MONGO_URL' });
+
+  // Guard before handing the URL to mongoose: an empty/invalid CORE_MONGO_URL
+  // makes mongoose.createConnection throw AND emit an unhandled 'error' event
+  // that crashes the whole process, bypassing callers' try/catch. Failing fast
+  // here keeps the rejection catchable (e.g. SaaS limit checks fall back to the
+  // enterprise/unlimited path when SaaS core isn't configured locally).
+  if (!/^mongodb(\+srv)?:\/\//.test(CORE_MONGO_URL)) {
+    throw new Error(
+      'CORE_MONGO_URL is not configured (expected a mongodb:// connection string)',
+    );
+  }
+
+  const coreConnection = await mongoose.createConnection(
+    CORE_MONGO_URL,
+    mongooseConnectionOptions,
+  );
+
+  coreModelOrganizations = coreConnection.model(
+    'organizations',
+    saasOrganizationsSchema,
+  );
+
+  coreModelInstallations = coreConnection.model(
+    'installations',
+    saasInstallationSchema,
+  );
+  coreModelExperiences = coreConnection.model('experiences', experiencesSchema);
+  coreModelUsers = coreConnection.model('users', saasUserSchema);
+  coreModelEndpoints = coreConnection.model('endpoints', endPointSchema);
+  coreModelPromoCodes = coreConnection.model(
+    'promo_codes',
+    saasPromoCodeSchema,
+  );
+  coreModelAddons = coreConnection.model('addons', saasAddonSchema);
+  coreModelBundles = coreConnection.model('bundles', saasBundleSchema);
+  coreModelPlugins = coreConnection.model('plugins', saasPluginSchema);
+  coreModelOrganizationPlanHistories =
+    coreConnection.model<ISaasOrganizationPlanHistory>(
+      'organization_plan_histories',
+      saasOrganizationPlanHistorySchema as any,
+    );
+};
+
+export const ORGANIZATION_ID_MAPPING: { [key: string]: string } = {};
+
+export const getSaasOrganizationIdBySubdomain = async (
+  subdomain: string,
+): Promise<string> => {
+  if (ORGANIZATION_ID_MAPPING[subdomain]) {
+    return ORGANIZATION_ID_MAPPING[subdomain];
+  }
+
+  await getSaasCoreConnection();
+
+  const organization = await getSaasOrgsCache({ subdomain });
+
+  if (!organization) {
+    throw new Error(`Invalid host, subdomain: ${subdomain}`);
+  }
+
+  ORGANIZATION_ID_MAPPING[subdomain] = organization._id;
+
+  return ORGANIZATION_ID_MAPPING[subdomain];
+};
+
+export const getSaasOrgsCache = async ({
+  subdomain,
+  excludeSubdomains,
+  domain,
+}: {
+  subdomain?: string;
+  excludeSubdomains?: string[];
+  domain?: string;
+}): Promise<any> => {
+  const value = await redis.get('core_organizations');
+
+  let organizations: IOrganization[] = value ? JSON.parse(value) : [];
+
+  if (organizations.length === 0) {
+    organizations = await coreModelOrganizations.find({}).lean();
+
+    redis.set('core_organizations', JSON.stringify(organizations));
+  }
+
+  if (subdomain) {
+    return organizations.find((org) => org.subdomain === subdomain);
+  }
+
+  if (excludeSubdomains) {
+    return organizations.filter(
+      (org) => !excludeSubdomains.includes(org.subdomain),
+    );
+  }
+
+  if (domain) {
+    return organizations.find((org) => org.domain === domain);
+  }
+
+  return organizations;
+};
+
+export const getSaasOrganizations = async (email?: string) => {
+  await getSaasCoreConnection();
+
+  if (email) {
+    return coreModelOrganizations.find({ ownerEmail: email });
+  }
+
+  return coreModelOrganizations.find({});
+};
+
+export const getSaasOrganizationsByFilter = async (filter: any) => {
+  await getSaasCoreConnection();
+
+  if (filter) {
+    return coreModelOrganizations.find(filter);
+  }
+
+  return coreModelOrganizations.find({});
+};
+
+export const updateSaasOrganization = async (
+  subdomain: string,
+  update: object,
+) => {
+  await getSaasCoreConnection();
+
+  return coreModelOrganizations.updateOne({ subdomain }, { $set: update });
+};
+
+type OrganizationWithHelpCenterDomains = Pick<
+  IOrganization,
+  'subdomain' | 'helpCenterDomain' | 'helpCenterDomains'
+>;
+
+const HELP_CENTER_DOMAIN_FIELDS = {
+  subdomain: 1,
+  helpCenterDomain: 1,
+  helpCenterDomains: 1,
+};
+
+/** The organization's help center domains, the legacy single one included. */
+export const helpCenterDomainsOf = (
+  organization?: Partial<OrganizationWithHelpCenterDomains> | null,
+): ISaasHelpCenterDomain[] => {
+  const domains = [...(organization?.helpCenterDomains || [])];
+  const legacy = organization?.helpCenterDomain;
+
+  if (
+    legacy?.hostname &&
+    !domains.some((domain) => domain.hostname === legacy.hostname)
+  ) {
+    domains.push(legacy);
+  }
+
+  return domains;
+};
+
+export const getSaasOrganizationByHelpCenterDomain = async (
+  hostname: string,
+): Promise<{ subdomain: string; domain: ISaasHelpCenterDomain } | null> => {
+  await getSaasCoreConnection();
+
+  const organization: OrganizationWithHelpCenterDomains | null =
+    await coreModelOrganizations
+      .findOne(
+        {
+          $or: [
+            { 'helpCenterDomains.hostname': hostname },
+            { 'helpCenterDomain.hostname': hostname },
+          ],
+        },
+        HELP_CENTER_DOMAIN_FIELDS,
+      )
+      .lean();
+
+  const domain = helpCenterDomainsOf(organization).find(
+    (entry) => entry.hostname === hostname,
+  );
+
+  return organization && domain
+    ? { subdomain: organization.subdomain, domain }
+    : null;
+};
+
+export const getSaasOrganizationHelpCenterDomains = async (
+  subdomain: string,
+): Promise<ISaasHelpCenterDomain[]> => {
+  await getSaasCoreConnection();
+
+  const organization = await coreModelOrganizations
+    .findOne({ subdomain }, HELP_CENTER_DOMAIN_FIELDS)
+    .lean();
+
+  return helpCenterDomainsOf(organization);
+};
+
+/**
+ * Organizations with a help center domain still waiting on DNS or its
+ * certificate within its background check window. Callers pick the pending
+ * entries out with helpCenterDomainsOf; active domains are skipped there.
+ */
+export const getSaasOrganizationsWithPendingHelpCenterDomain =
+  async (): Promise<OrganizationWithHelpCenterDomains[]> => {
+    await getSaasCoreConnection();
+
+    const pending = {
+      hostname: { $exists: true },
+      autoCheckUntil: { $gt: new Date() },
+      $or: [{ status: { $ne: 'active' } }, { sslStatus: { $ne: 'active' } }],
+    };
+
+    return coreModelOrganizations
+      .find(
+        {
+          $or: [
+            { helpCenterDomains: { $elemMatch: pending } },
+            {
+              'helpCenterDomain.hostname': { $exists: true },
+              'helpCenterDomain.autoCheckUntil': { $gt: new Date() },
+              $or: [
+                { 'helpCenterDomain.status': { $ne: 'active' } },
+                { 'helpCenterDomain.sslStatus': { $ne: 'active' } },
+              ],
+            },
+          ],
+        },
+        HELP_CENTER_DOMAIN_FIELDS,
+      )
+      .lean();
+  };
+
+// Moves a legacy single domain into the list, so writes only touch the list.
+const moveLegacyHelpCenterDomain = async (subdomain: string) => {
+  const organization = await coreModelOrganizations
+    .findOne(
+      { subdomain, 'helpCenterDomain.hostname': { $exists: true } },
+      HELP_CENTER_DOMAIN_FIELDS,
+    )
+    .lean();
+
+  if (!organization) {
+    return;
+  }
+
+  await coreModelOrganizations.updateOne(
+    { subdomain, helpCenterDomain: { $exists: true } },
+    {
+      $set: { helpCenterDomains: helpCenterDomainsOf(organization) },
+      $unset: { helpCenterDomain: 1 },
+    },
+  );
+};
+
+/** Adds the domain, or replaces the stored one with the same hostname. */
+export const saveSaasOrganizationHelpCenterDomain = async (
+  subdomain: string,
+  domain: ISaasHelpCenterDomain,
+) => {
+  await getSaasCoreConnection();
+  await moveLegacyHelpCenterDomain(subdomain);
+
+  const replaced = await coreModelOrganizations.updateOne(
+    { subdomain, 'helpCenterDomains.hostname': domain.hostname },
+    { $set: { 'helpCenterDomains.$': domain } },
+  );
+
+  if (!replaced.matchedCount) {
+    await coreModelOrganizations.updateOne(
+      { subdomain, 'helpCenterDomains.hostname': { $ne: domain.hostname } },
+      { $push: { helpCenterDomains: domain } },
+    );
+  }
+
+  return removeOrgsCache('helpCenterDomain');
+};
+
+export const removeSaasOrganizationHelpCenterDomain = async (
+  subdomain: string,
+  hostname: string,
+) => {
+  await getSaasCoreConnection();
+  await moveLegacyHelpCenterDomain(subdomain);
+
+  await coreModelOrganizations.updateOne(
+    { subdomain },
+    { $pull: { helpCenterDomains: { hostname } } },
+  );
+
+  return removeOrgsCache('helpCenterDomain');
+};
+
+export const getSaasOrganizationDetail = async ({
+  subdomain,
+}: {
+  subdomain: string;
+}) => {
+  await getSaasCoreConnection();
+
+  const organization = await coreModelOrganizations
+    .findOne({ subdomain })
+    .lean();
+
+  if (!organization) {
+    return {};
+  }
+
+  const charge = organization.charge || {};
+  let experienceName = '';
+  const bundleNames = [] as string[];
+  const setupService: Record<string, boolean> = {};
+
+  const installation = await coreModelInstallations.findOne({
+    organizationId: organization._id,
+  });
+
+  if (installation) {
+    const plugins = await getSaasPlugins({});
+    const addons = await coreModelAddons.find(
+      {
+        installationId: installation._id.toString(),
+        expiryDate: { $gt: new Date() },
+        paymentStatus: { $in: ['complete', 'canceled'] },
+      },
+      { quantity: 1, kind: 1 },
+    );
+
+    const bundleTypes = await coreModelBundles.find({}).distinct('type').lean();
+
+    const activeBundles = await coreModelAddons
+      .find({
+        installationId: installation._id.toString(),
+        kind: { $in: bundleTypes },
+        paymentStatus: { $in: ['complete', 'canceled'] },
+        expiryDate: { $gt: new Date() },
+      })
+      .lean();
+
+    for (const activeBundle of activeBundles) {
+      const bundle = await coreModelBundles.findOne({
+        type: activeBundle.kind,
+      });
+
+      bundleNames.push(bundle.title);
+    }
+
+    for (const plugin of plugins) {
+      let purchased = 0;
+      let quantity = 0;
+      let free = charge[plugin.type] ? charge[plugin.type].free || 0 : 0;
+      let bundleAmount = 0;
+
+      if (activeBundles && activeBundles.length > 0) {
+        for (const activeBundle of activeBundles) {
+          const bundle = await coreModelBundles.findOne({
+            type: activeBundle.kind,
+          });
+
+          if (bundle) {
+            bundleAmount = bundle.pluginLimits
+              ? bundle.pluginLimits[plugin.type] || 0
+              : 0;
+          }
+        }
+      }
+
+      addons
+        .filter((addon: any) => addon.kind === plugin.type)
+        .forEach((addon: any) => {
+          quantity += addon.quantity || 0;
+        });
+
+      if (organization?.experienceId) {
+        const experience = await coreModelExperiences.findOne({
+          _id: organization.experienceId,
+        });
+
+        if (experience) {
+          experienceName = experience.title;
+          free =
+            free +
+            (experience.pluginLimits
+              ? experience.pluginLimits[plugin.type] || 0
+              : 0);
+        }
+      }
+
+      purchased = quantity + (bundleAmount || 0) / (plugin.count || 1);
+
+      charge[plugin.type] = {
+        ...charge[plugin.type],
+        free,
+        purchased,
+      };
+    }
+
+    const setupAddons = await coreModelAddons.find(
+      {
+        installationId: installation._id.toString(),
+        paymentStatus: 'complete',
+        kind: 'setupService',
+      },
+      { subkind: 1 },
+    );
+
+    for (const addon of setupAddons) {
+      setupService[addon.subkind] = true;
+    }
+  }
+
+  if (organization?.bundleId) {
+    const bundle = await coreModelBundles.findOne({
+      _id: organization.bundleId,
+    });
+
+    if (bundle) {
+      organization.bundle = {
+        bundleId: organization.bundleId,
+        title: bundle.title,
+        type: bundle.type,
+      };
+    }
+  }
+
+  return {
+    ...organization,
+    experienceName,
+    bundleNames,
+    charge,
+    setupService,
+  };
+};
+
+export const getSaasOrganizationPlanHistories = async ({
+  organizationId,
+  statuses = ['active'],
+}: {
+  organizationId: string;
+  statuses?: string[];
+}): Promise<ISaasOrganizationPlanHistory[]> => {
+  await getSaasCoreConnection();
+
+  const histories = await coreModelOrganizationPlanHistories
+    .find({
+      organizationId,
+      ...(statuses.length ? { status: { $in: statuses } } : {}),
+    })
+    .sort({ createdAt: -1 })
+    .lean<ISaasOrganizationPlanHistory[]>();
+
+  const bundleIds = Array.from(
+    new Set(histories.map((history) => history.bundleId).filter(Boolean)),
+  );
+
+  if (!bundleIds.length) {
+    return histories;
+  }
+
+  const bundles = await coreModelBundles
+    .find({ _id: { $in: bundleIds } })
+    .lean();
+
+  const bundleById = new Map<string, ISaasBundle>(
+    bundles.map((bundle: any) => [String(bundle._id), bundle as ISaasBundle]),
+  );
+
+  return histories.map((history) => ({
+    ...history,
+    bundle: history.bundleId ? bundleById.get(history.bundleId) : undefined,
+  }));
+};
+
+export const getSaasOrganizationActiveAddons = async ({
+  organizationId,
+}: {
+  organizationId: string;
+}): Promise<ISaasAddon[]> => {
+  await getSaasCoreConnection();
+
+  const installation = await coreModelInstallations
+    .findOne({ organizationId }, { _id: 1 })
+    .lean();
+
+  if (!installation?._id) {
+    return [];
+  }
+
+  const addons = (await coreModelAddons
+    .find({
+      installationId: String(installation._id),
+      paymentStatus: 'complete',
+      isCanceled: { $ne: true },
+      $or: [{ expiryDate: { $gt: new Date() } }, { interval: 'oneTime' }],
+    })
+    .sort({ createdAt: -1 })
+    .lean()) as ISaasAddon[];
+
+  const bundleTypes = Array.from(
+    new Set(addons.map((addon) => addon.kind).filter(Boolean)),
+  );
+
+  if (!bundleTypes.length) {
+    return addons;
+  }
+
+  const bundles = await coreModelBundles
+    .find({ type: { $in: bundleTypes } })
+    .lean();
+
+  const bundleByType = new Map<string, ISaasBundle>(
+    bundles.map((bundle: any) => [String(bundle.type), bundle as ISaasBundle]),
+  );
+
+  return addons.map((addon) => ({
+    ...addon,
+    bundle: addon.kind ? bundleByType.get(addon.kind) : undefined,
+  }));
+};
+
+export const removeOrgsCache = (source: string) => {
+  console.log(`Removing org cache ${source}`);
+
+  return redis.set('core_organizations', '');
+};
+
+export const getSaasPlugins = async (query: any = {}) => {
+  await getSaasCoreConnection();
+
+  return coreModelPlugins.find(query).lean();
+};
+
+export const getSaasPlugin = async (query: any = {}) => {
+  await getSaasCoreConnection();
+
+  return coreModelPlugins.findOne(query).lean();
+};
+
+export const getSaasPromoCodes = async (query: any = {}) => {
+  await getSaasCoreConnection();
+
+  return coreModelPromoCodes.find(query).lean();
+};
+
+export const getSaasOrgPromoCodes = async ({
+  promoCodes = [],
+}: IOrganization) => {
+  if (!promoCodes.length) {
+    return [];
+  }
+
+  return getSaasPromoCodes({
+    code: { $in: promoCodes },
+  });
+};

package/src/utils/saas/types.ts

@@ -0,0 +1,107 @@
+export interface ISaasHelpCenterDomainRecord {
+  name: string;
+  value: string;
+}
+
+export interface ISaasHelpCenterDomain {
+  hostname: string;
+  // The help center the domain serves. Unset on a domain connected before
+  // domains were per help center: it serves the workspace's default one.
+  helpCenterId?: string;
+  cloudflareId?: string;
+  // Cloudflare custom hostname status: pending, active, moved, blocked, ...
+  status?: string;
+  sslStatus?: string;
+  // Whether the hostname CNAMEs to the tenant's help center: pending or active
+  dnsStatus?: string;
+  ownershipVerification?: ISaasHelpCenterDomainRecord;
+  sslValidationRecords?: ISaasHelpCenterDomainRecord[];
+  verificationErrors?: string[];
+  // While pending, checked in the background until this date; unset once active
+  autoCheckUntil?: Date;
+  lastCheckedAt?: Date;
+  createdAt?: Date;
+}
+
+export interface IOrganization {
+  _id?: string;
+  name: string;
+  subdomain: string;
+  ownerId: string;
+  plan: string;
+  expiryDate: string;
+  icon: string;
+  teamMembersLimit: number;
+  interval: string;
+  charge: any;
+
+  logo?: string;
+  favicon?: string;
+  iconColor?: string;
+  description?: string;
+  dnsStatus?: string;
+  backgroundColor?: string;
+  isWhiteLabel?: boolean;
+  isNext?: boolean;
+  bundleId?: string;
+  domain?: string;
+  textColor?: string;
+  lastActiveDate?: Date;
+  cronLastExecutedDate?: any;
+  createdAt?: Date;
+  promoCodes?: string[];
+  partnerKey?: string;
+  awsSesAccountStatus?: string;
+  customDomainStatus?: Record<string, unknown>;
+  hostNameStatus?: string;
+  sslStatus?: string;
+  // Legacy single domain, moved into helpCenterDomains on the next write
+  helpCenterDomain?: ISaasHelpCenterDomain;
+  helpCenterDomains?: ISaasHelpCenterDomain[];
+}
+
+export interface ISaasBundle {
+  _id?: string;
+  title?: string;
+  type?: string;
+  isFree?: boolean;
+  pluginsLimits?: Record<string, unknown>;
+}
+
+export interface ISaasAddon {
+  _id?: string;
+  kind?: string;
+  quantity?: number;
+  installationId?: string;
+  subscriptionId?: string;
+  expiryDate?: Date;
+  interval?: string;
+  paymentStatus?: string;
+  paymentStatusMessage?: string;
+  isCanceled?: boolean;
+  createdAt?: Date;
+  updatedAt?: Date;
+  bundle?: ISaasBundle;
+}
+
+export interface ISaasOrganizationPlanHistory {
+  _id?: string;
+  organizationId: string;
+  source?: string;
+  status?: string;
+  isNext?: boolean;
+  productId?: string;
+  bundleId?: string;
+  interval?: string;
+  pluginsLimitsSnapshot?: Record<string, unknown>;
+  assistantLimit?: number;
+  stripeCheckoutSessionId?: string;
+  stripePaymentIntentId?: string;
+  stripeSubscriptionId?: string;
+  stripeInvoiceId?: string;
+  startsAt?: Date;
+  endsAt?: Date;
+  createdAt?: Date;
+  updatedAt?: Date;
+  bundle?: ISaasBundle;
+}