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

package/src/utils/mq-worker.ts

@@ -0,0 +1,150 @@
+import type {
+  DefaultJobOptions,
+  Job,
+  JobsOptions,
+  Worker as WorkerType,
+  WorkerOptions,
+} from 'bullmq';
+import { Queue, QueueEvents, Worker } from 'bullmq';
+import type { Redis } from 'ioredis';
+import { redis } from './redis';
+// Kept in its own module so it can be tested without opening a connection.
+import { toSerializablePayload } from './serializablePayload';
+
+export { toSerializablePayload };
+
+const queueMap = new Map<string, Queue>();
+const queueEventsMap = new Map<string, QueueEvents>();
+
+export const DEFAULT_JOB_OPTIONS: DefaultJobOptions = {
+  removeOnComplete: true,
+  removeOnFail: { count: 5000, age: 24 * 3600 },
+};
+
+const makeQueueSerializable = (queue: Queue) => {
+  const serializableQueue = queue as Queue & {
+    isSerializableAddWrapped?: boolean;
+  };
+
+  if (serializableQueue.isSerializableAddWrapped) {
+    return serializableQueue;
+  }
+
+  const add = serializableQueue.add.bind(serializableQueue);
+
+  serializableQueue.add = ((name: string, data?: unknown, opts?: JobsOptions) =>
+    add(name, toSerializablePayload(data), opts)) as Queue['add'];
+  serializableQueue.isSerializableAddWrapped = true;
+
+  return serializableQueue;
+};
+
+export const createMQWorkerWithListeners = (
+  service: string,
+  queueName: string,
+  processor: (job: Job) => Promise<any>,
+  redis: Redis,
+  onReady: () => void,
+  workerOptions: Omit<WorkerOptions, 'connection'> = {},
+): WorkerType => {
+  const worker = new Worker(`${service}-${queueName}`, processor, {
+    connection: redis,
+    ...workerOptions,
+  });
+
+  // Default event listeners
+  worker.on('completed', (job) => {
+    console.log(
+      `[Worker] Job ${job.id} in queue '${service}-${queueName}' completed successfully`,
+    );
+  });
+
+  worker.on('failed', (job, err) => {
+    console.error(
+      `[Worker] Job ${job?.id} in queue '${service}-${queueName}' failed with error: ${err.message}`,
+    );
+  });
+
+  worker.on('error', (err) => {
+    console.error(
+      `[Worker] Error in worker for queue '${service}-${queueName}': ${err.message}`,
+    );
+  });
+
+  worker.on('ready', () => {
+    console.log(`[Worker] Worker for queue '${service}-${queueName}' is ready`);
+    onReady();
+  });
+
+  return worker;
+};
+
+export const sendWorkerQueue = (serviceName: string, queueName: string) => {
+  const queueKey = `${serviceName}-${queueName}`;
+  let queue = queueMap.get(queueKey);
+
+  if (!queue) {
+    queue = new Queue(queueKey, {
+      connection: redis,
+      defaultJobOptions: DEFAULT_JOB_OPTIONS,
+    });
+    makeQueueSerializable(queue);
+    queueMap.set(queueKey, queue);
+  }
+
+  return queue;
+};
+
+export const sendWorkerMessage = async ({
+  pluginName,
+  queueName,
+  jobName,
+  subdomain,
+  data,
+  defaultValue,
+  timeout = 3000,
+  options,
+}: {
+  pluginName: string;
+  queueName: string;
+  jobName: string;
+  subdomain: string;
+  data: any;
+  defaultValue?: any;
+  timeout?: number;
+  options?: DefaultJobOptions;
+}) => {
+  const queueKey = `${pluginName}-${queueName}`;
+
+  // Get or create the Queue instance
+  let queue = queueMap.get(queueKey);
+  if (!queue) {
+    queue = new Queue(queueKey, {
+      connection: redis,
+      defaultJobOptions: DEFAULT_JOB_OPTIONS,
+    });
+    makeQueueSerializable(queue);
+    queueMap.set(queueKey, queue);
+  }
+
+  // Get or create the QueueEvents instance
+  let queueEvents = queueEventsMap.get(queueKey);
+  if (!queueEvents) {
+    queueEvents = new QueueEvents(queueKey, { connection: redis });
+    await queueEvents.waitUntilReady(); // Only need to wait on first init
+    queueEventsMap.set(queueKey, queueEvents);
+  }
+
+  const jobData = toSerializablePayload({ subdomain, data });
+  const job = await queue.add(jobName, jobData, { ...options });
+  const result = await Promise.race([
+    job.waitUntilFinished(queueEvents),
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('Worker timeout')), timeout),
+    ),
+  ]).catch((err) => {
+    throw err;
+  });
+
+  return result || defaultValue;
+};

package/src/utils/random.ts

@@ -0,0 +1,6 @@
+import { customAlphabet } from 'nanoid';
+
+export const randomAlphanumeric = customAlphabet(
+  'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+);
+export const randomLowercase = customAlphabet('abcdefghijklmnopqrstuvwxyz');

package/src/utils/redis.ts

@@ -0,0 +1,23 @@
+import Redis from 'ioredis';
+
+const { REDIS_HOST, REDIS_PORT, REDIS_PASSWORD } = process.env;
+
+export const redis = new Redis({
+  host: REDIS_HOST,
+  port: Number.parseInt(REDIS_PORT || '6379', 10),
+  password: REDIS_PASSWORD,
+  connectTimeout: 20_000,
+  maxRetriesPerRequest: null,
+  reconnectOnError: (error) => {
+    const targetErrors = [/READONLY/, /ETIMEDOUT/];
+    if (targetErrors.some((targetError) => targetError.test(error.message))) {
+      return 2;
+    } else {
+      return false;
+    }
+  },
+});
+
+export const resetConfigsCache = async () => {
+  await redis.set('configs_erxes_api', '');
+};

package/src/utils/saas/constants.ts

@@ -0,0 +1,32 @@
+export const SAAS_PROMO_CODE_TYPE = {
+  APPSUMO: 'appsumo',
+  ALL: ['appsumo'],
+};
+
+export const SAAS_ORGANIZATION_PLAN = {
+  LIFETIME: 'lifetime',
+  FREE: 'free',
+  GROWTH: 'growth',
+  ALL: ['lifetime', 'free', 'growth'],
+};
+
+export const SAAS_PROMOCODE_STATUS = {
+  REDEEMED: 'redeemed',
+  REVOKED: 'revoked',
+  UNUSED: 'unused',
+  ALL: ['redeemed', 'revoked', 'unused'],
+};
+
+export const SAAS_PAYMENT_STATUS = {
+  INCOMPLETE: 'incomplete',
+  ERROR: 'error',
+  COMPLETE: 'complete',
+  CANCELED: 'canceled',
+  ALL: ['canceled', 'incomplete', 'complete', 'error'],
+};
+
+export const SAAS_ORGANIZATION_INTERVAL = {
+  MONTHLY: 'monthly',
+  YEARLY: 'yearly',
+  ALL: ['monthly', 'yearly'],
+};

package/src/utils/saas/definition.ts

@@ -0,0 +1,318 @@
+import mongoose from 'mongoose';
+import {
+  SAAS_ORGANIZATION_PLAN,
+  SAAS_PROMO_CODE_TYPE,
+  SAAS_PROMOCODE_STATUS,
+  SAAS_PAYMENT_STATUS,
+  SAAS_ORGANIZATION_INTERVAL,
+} from './constants';
+
+const saasCronLastExecutedDateSchema = new mongoose.Schema(
+  {
+    reset: Date,
+    notify: Date,
+  },
+  { _id: false },
+);
+
+export const saasOrganizationsSchema = new mongoose.Schema({
+  name: { type: String },
+  logo: { type: String },
+  icon: { type: String },
+  iconColor: { type: String },
+  textColor: { type: String },
+  favicon: { type: String },
+  description: { type: String },
+  dnsStatus: { type: String },
+  backgroundColor: { type: String },
+  isWhiteLabel: { type: Boolean, optional: true, default: false },
+  domain: { type: String },
+  subdomain: { type: String },
+  ownerId: { type: String },
+  charge: { type: Object },
+  promoCodes: { type: [String] },
+  partnerKey: { type: String },
+  lastActiveDate: { type: Date },
+  createdAt: { type: Date },
+  teamMembersLimit: { type: Number, required: true },
+  plan: {
+    type: String,
+    enum: SAAS_ORGANIZATION_PLAN.ALL,
+    default: SAAS_ORGANIZATION_PLAN.FREE,
+  },
+  interval: {
+    type: String,
+    enum: SAAS_ORGANIZATION_INTERVAL.ALL,
+    optional: true,
+  },
+  subscriptionId: { type: String, optional: true },
+  expiryDate: { type: Date, label: 'Expiry date', optional: true },
+  cronLastExecutedDate: { type: saasCronLastExecutedDateSchema },
+  awsSesAccountStatus: {
+    type: String,
+    label: 'AWS SES account status',
+    optional: true,
+  },
+  percentOff: Number,
+  amountOff: Number,
+  paymentStatus: { type: String },
+  paymentStatusMessage: { type: String },
+  teamSize: { type: String },
+  industry: { type: String },
+  annualRevenue: { type: String },
+  experienceId: { type: String },
+  onboardedPlugins: { type: [String] },
+  customDomainStatus: { type: Object },
+
+  hostNameStatus: { type: String },
+  sslStatus: { type: String },
+
+  cycleEnabled: { type: Boolean },
+
+  // Kept apart from `domain` / `dnsStatus`, which drive the white-label app
+  // domain, so a help center hostname never changes how the app sets cookies.
+  helpCenterDomain: { type: Object },
+  // One entry per connected help center domain (see ISaasHelpCenterDomain)
+  helpCenterDomains: { type: [Object], default: undefined },
+});
+
+export const saasInstallationSchema = new mongoose.Schema({
+  createdAt: { type: Date, label: 'Created at', default: new Date() },
+  userId: { type: String, label: 'Owner user' },
+  organizationId: { type: String, label: 'Linked organization' },
+  name: { type: String, label: 'Self hosted installation name' },
+  token: { type: String, label: 'Token' },
+  isVerified: { type: Boolean, default: false },
+  domain: { type: String, label: 'Self hosted domain' },
+});
+
+export const saasPaymentSchema = new mongoose.Schema({
+  createdAt: { type: Date, default: Date.now },
+  organizationId: { type: String },
+  amount: { type: Number },
+  invoiceId: { type: String },
+});
+
+export const saasUserSchema = new mongoose.Schema({
+  organizationIds: { type: [String] },
+  email: { type: String },
+});
+
+export const endPointSchema = new mongoose.Schema({
+  endPointUrl: { type: String },
+});
+
+export const saasPromoCodeSchema = new mongoose.Schema({
+  code: { type: String, unique: true },
+  status: {
+    type: String,
+    enum: SAAS_PROMOCODE_STATUS.ALL,
+    default: SAAS_PROMOCODE_STATUS.UNUSED,
+  },
+  usedBy: { type: String, label: 'Used by' },
+  usedAt: {
+    type: Date,
+    label: 'Used at',
+  },
+  type: { type: String, enum: SAAS_PROMO_CODE_TYPE.ALL },
+  createdBy: { type: String, label: 'Created by' },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+    label: 'Created at',
+  },
+});
+
+export const saasAddonSchema = new mongoose.Schema({
+  kind: { type: String, label: 'Add-on kind' },
+  subkind: { type: String, label: 'For example: It is used for setup service' },
+  quantity: { type: Number, label: 'Quantity' },
+  unitAmount: { type: Number, label: 'Unit amount' },
+  installationId: { type: String, label: 'Linked installation' },
+  subscriptionItemId: {
+    type: String,
+    label: 'Linked subscription item if purchased',
+  },
+  subscriptionId: { type: String, label: 'Linked subscription if purchased' },
+  expiryDate: { type: Date, label: 'Expiry date if purchased' },
+  createdUser: { type: String, label: 'Created user' },
+  interval: String,
+  percentOff: Number,
+  amountOff: Number,
+  paymentStatus: {
+    type: String,
+    enum: SAAS_PAYMENT_STATUS.ALL,
+    label: 'Картнаас төлбөр татагдсан тохиолдолд утга нь complete болно.',
+  },
+  paymentStatusMessage: {
+    type: String,
+    label: 'Төлбөр төлөгдсөн талаарх тайлбар',
+  },
+  createdAt: { type: Date },
+  isCanceled: { type: Boolean },
+});
+
+export const saasBundleSchema = new mongoose.Schema({
+  name: { type: String },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+    label: 'Created at',
+  },
+  title: { type: String },
+  type: { type: String },
+  stripeProductId: { type: String, label: 'Product id at stripe' },
+  pluginLimits: {
+    type: mongoose.Schema.Types.Mixed,
+    label: 'Plugins information',
+  },
+  comingSoon: {
+    type: Boolean,
+    label: 'Show different things in UI if coming soon',
+  },
+  isActive: { type: Boolean, label: '' },
+  promoCodes: { type: [String], label: 'Promo codes' },
+  description: { type: String, label: 'Description' },
+  onboardingSteps: { type: [String], label: 'Onboarding steps' },
+  onboardingDescription: { type: String, label: 'Onboarding description' },
+  features: { type: String, label: 'Features' },
+  detailedDescription: { type: String, label: 'Detailed Description' },
+});
+
+const creatorSchema = new mongoose.Schema(
+  {
+    name: { type: String },
+    address: { type: String },
+    email: { type: String },
+    phone: { type: String },
+  },
+  { _id: false },
+);
+
+export const PLUGIN_MAIN_TYPES = {
+  ADDON: 'addon',
+  PLUGIN: 'plugin',
+  SERVICE: 'service',
+  POWERUP: 'power-up',
+  ALL: ['addon', 'plugin', 'service', 'power-up'],
+};
+
+export const saasPluginSchema = new mongoose.Schema({
+  language: { type: String, label: 'Language' },
+
+  avatar: { type: String, label: 'Avatar' },
+  images: { type: String, label: 'Images' },
+  video: { type: String, label: 'Video' },
+
+  title: { type: String, label: 'Plugin title' },
+  creator: { type: creatorSchema, label: 'Creator info' },
+  department: { type: String, label: 'Department' },
+
+  description: { type: String, label: 'Description' },
+  shortDescription: { type: String, label: 'Short description' },
+  screenShots: { type: String, label: 'Screen shots' },
+  features: { type: String, label: 'Features' },
+
+  tango: { type: String, label: 'Tango' },
+
+  changeLog: { type: String, label: 'Change log' },
+  lastUpdatedInfo: { type: String, label: 'Last updated information' },
+  contributors: { type: String, label: 'Contributors' },
+  support: { type: String, label: 'Resolved issues' },
+
+  createdAt: { type: Date, label: 'Created at' },
+  updatedAt: { type: Date, label: 'Modified at' },
+  createdBy: { type: String, label: 'Created by' },
+  modifiedBy: { type: String, label: 'Modified by' },
+
+  selfHosted: { type: Boolean, label: 'For self hosted or not' },
+  type: {
+    type: String,
+    label: 'Value previously stored in charge item type constant variable',
+  },
+  limit: { type: Number, label: 'Limit' },
+  count: { type: Number, label: 'Count' },
+  initialCount: { type: Number, label: 'Initial count' },
+  growthInitialCount: { type: Number },
+  resetMonthly: { type: Boolean, label: 'Whether limit resets monthly or not' },
+  unit: { type: String, label: 'Measurement unit' },
+  comingSoon: {
+    type: Boolean,
+    label: 'Show different things in UI if coming soon',
+  },
+  icon: { type: String, label: 'Icon path' },
+  categories: {
+    type: [String],
+    label: 'Related categories (marketing, sales ...etc)',
+  },
+  dependencies: { type: [String], label: 'Dependent plugin ids' },
+  mainType: {
+    type: [String],
+    label: 'Whether a plugin, addon, service or power-up',
+    enum: PLUGIN_MAIN_TYPES.ALL,
+  },
+  stripeProductId: { type: String, label: 'Product id at stripe' },
+});
+
+export const experiencesSchema = new mongoose.Schema({
+  title: { type: String },
+  images: { type: String, label: 'images' },
+  video: { type: String, label: 'video' },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+    label: 'Created at',
+  },
+  stripeProductId: { type: String, label: 'Product id at stripe' },
+  pluginLimits: {
+    type: mongoose.Schema.Types.Mixed,
+    label: 'Plugins information',
+  },
+  comingSoon: {
+    type: Boolean,
+    label: 'Show different things in UI if coming soon',
+  },
+  isPrivate: {
+    type: Boolean,
+    label: 'Show different things in UI if coming soon',
+  },
+  isActive: { type: Boolean, label: '' },
+  promoCodes: { type: [String], label: 'Promo codes' },
+  description: { type: String, label: 'Description' },
+  onboardingSteps: { type: [String], label: 'Onboarding steps' },
+  onboardingDescription: { type: String, label: 'Onboarding description' },
+  features: { type: String, label: 'Features' },
+});
+
+export const saasOrganizationPlanHistorySchema = new mongoose.Schema(
+  {
+    organizationId: { type: String, index: true },
+    source: { type: String, index: true },
+    status: { type: String, index: true },
+
+    isNext: { type: Boolean },
+    productId: { type: String },
+    bundleId: { type: String },
+    interval: { type: String },
+    description: { type: String },
+
+    pluginsLimitsSnapshot: { type: mongoose.Schema.Types.Mixed },
+    assistantLimit: { type: Number },
+
+    stripeCheckoutSessionId: {
+      type: String,
+      index: true,
+      unique: true,
+      sparse: true,
+    },
+    stripePaymentIntentId: { type: String, index: true },
+    stripeSubscriptionId: { type: String, index: true },
+    stripeInvoiceId: { type: String, index: true },
+
+    startsAt: { type: Date },
+    endsAt: { type: Date },
+  },
+  {
+    timestamps: true,
+  },
+);

package/src/utils/saas/index.ts

@@ -0,0 +1,2 @@
+export * from './saas-mongo-connection';
+export * from './types';