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

package/src/core-modules/client-portals/definitions/cpUser.ts

@@ -0,0 +1,236 @@
+import { Schema } from 'mongoose';
+
+import { mongooseStringRandomId } from '../../../utils';
+export const cpNotificationConfigUserSchema = new Schema(
+  {
+    notificationType: {
+      type: String,
+      required: true,
+    },
+    isAllowed: {
+      type: Boolean,
+      default: true,
+    },
+    label: {
+      type: String,
+      required: true,
+    },
+  },
+  { _id: false },
+);
+
+export const cpTwoFactor = new Schema(
+  {
+    device: {
+      type: String,
+    },
+    key: {
+      type: String,
+    },
+    date: {
+      type: Date,
+      default: Date.now,
+      label: 'login at',
+    },
+  },
+  { _id: false },
+);
+
+export const cpNotificationSettingsSchema = new Schema(
+  {
+    receiveByEmail: {
+      type: Boolean,
+      required: true,
+    },
+    receiveBySms: {
+      type: Boolean,
+      required: true,
+    },
+    configs: {
+      type: [cpNotificationConfigUserSchema],
+      required: true,
+    },
+  },
+  { _id: false },
+);
+
+export const refreshTokenSchema = new Schema(
+  {
+    token: { type: String, required: true },
+    deviceId: { type: String },
+    userAgent: { type: String },
+    ipAddress: { type: String },
+    createdAt: { type: Date, default: Date.now },
+    expiresAt: { type: Date, required: true },
+  },
+  { _id: false },
+);
+
+export const socialAuthProviderSchema = new Schema(
+  {
+    provider: {
+      type: String,
+      enum: ['GOOGLE', 'FACEBOOK', 'APPLE'],
+      required: true,
+    },
+    providerId: { type: String, required: true },
+    email: { type: String },
+    linkedAt: { type: Date, default: Date.now },
+  },
+  { _id: false },
+);
+
+export const fcmDeviceSchema = new Schema(
+  {
+    deviceId: { type: String, required: true },
+    token: { type: String, required: true },
+    platform: {
+      type: String,
+      required: true,
+      enum: ['ios', 'android', 'web'],
+    },
+  },
+  { _id: false },
+);
+
+const actionCodeSchema = new Schema(
+  {
+    code: { type: String, required: true },
+    expires: { type: Date, required: true },
+    type: {
+      type: String,
+      required: true,
+      enum: [
+        'EMAIL_VERIFICATION',
+        'PHONE_VERIFICATION',
+        'PASSWORD_RESET',
+        'TWO_FACTOR_VERIFICATION',
+        'EMAIL_CHANGE',
+        'PHONE_CHANGE',
+      ],
+    },
+  },
+  { _id: false },
+);
+
+const verificationRequestSchema = new Schema(
+  {
+    status: { type: String, required: true },
+    attachments: { type: [Object], required: true },
+    description: { type: String },
+    verifiedBy: { type: String },
+  },
+  { _id: false },
+);
+
+export const cpUserSchema = new Schema(
+  {
+    _id: mongooseStringRandomId,
+    type: {
+      type: String,
+      enum: ['customer', 'company'],
+      default: 'customer',
+    },
+    email: {
+      type: String,
+      match: [
+        /^[a-zA-Z0-9]+([._-][a-zA-Z0-9]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z]{2,10})+$/,
+        'Please fill a valid email address',
+      ],
+      label: 'Email',
+      sparse: true,
+    },
+    phone: { type: String, sparse: true },
+    pendingEmail: { type: String },
+    pendingPhone: { type: String },
+    username: {
+      type: String,
+      unique: true,
+      sparse: true,
+    },
+    code: { type: String },
+    password: { type: String },
+    firstName: {
+      type: String,
+      label: 'First name',
+    },
+    lastName: { type: String, label: 'Last name' },
+    avatar: { type: String, label: 'Avatar' },
+
+    companyName: {
+      type: String,
+      label: 'Company name',
+    },
+    companyRegistrationNumber: {
+      type: String,
+      label: 'Company registration number',
+    },
+    isVerified: {
+      type: Boolean,
+      required: true,
+      default: false,
+    },
+    clientPortalId: { type: String, required: true },
+    erxesCompanyId: { type: String },
+    erxesCustomerId: { type: String },
+    isPhoneVerified: {
+      type: Boolean,
+      required: true,
+      default: false,
+    },
+    isEmailVerified: {
+      type: Boolean,
+      required: true,
+      default: false,
+    },
+    fcmTokens: {
+      type: [fcmDeviceSchema],
+      default: [],
+    },
+    actionCode: {
+      type: actionCodeSchema,
+    },
+    customFieldsData: { type: Object },
+
+    // manual verification
+    verificationRequest: {
+      type: verificationRequestSchema,
+    },
+
+    // Refresh tokens for token management
+    refreshTokens: {
+      type: [refreshTokenSchema],
+      default: [],
+    },
+
+    // Social auth providers for account linking
+    socialAuthProviders: {
+      type: [socialAuthProviderSchema],
+      default: [],
+    },
+
+    // Security and tracking fields
+    failedLoginAttempts: { type: Number },
+    accountLockedUntil: { type: Date },
+    lastLoginAt: { type: Date },
+    primaryAuthMethod: {
+      type: String,
+      enum: ['email', 'phone', 'social'],
+    },
+    otpResendAttempts: { type: Number },
+    otpResendLastAttempt: { type: Date },
+  },
+  { timestamps: true },
+);
+cpUserSchema.index({ clientPortalId: 1 });
+cpUserSchema.index({ email: 1 });
+cpUserSchema.index({ phone: 1 });
+cpUserSchema.index(
+  { createdAt: 1 },
+  {
+    expireAfterSeconds: 24 * 60 * 60,
+    partialFilterExpression: {
+      $and: [{ isPhoneVerified: false }, { isEmailVerified: false }],
+    },
+  },
+);

package/src/core-modules/client-portals/index.ts

@@ -0,0 +1,4 @@
+export * from './definitions/clientPortal';
+export * from './definitions/cpUser';
+export * from './definitions/comment';
+export * from './definitions/cpNotification';

package/src/core-modules/common/db/definitions/common.ts

@@ -0,0 +1,43 @@
+import { Schema } from 'mongoose';
+import { mongooseField } from '../../../../utils';
+
+export const customFieldSchema = new Schema(
+  {
+    field: mongooseField({ type: 'String' }),
+    value: mongooseField({ type: Schema.Types.Mixed }),
+    stringValue: mongooseField({ type: 'String', optional: true }),
+    numberValue: mongooseField({ type: 'Number', optional: true }),
+    dateValue: mongooseField({ type: 'Date', optional: true }),
+  },
+  { _id: false },
+);
+
+// schema for form's rules
+export const ruleSchema = new Schema(
+  {
+    _id: mongooseField({ type: String }),
+
+    // browserLanguage, currentUrl, etc ...
+    kind: mongooseField({ type: String, label: 'Kind' }),
+
+    // Browser language, Current url etc ...
+    text: mongooseField({ type: String, label: 'Text' }),
+
+    // is, isNot, startsWith
+    condition: mongooseField({ type: String, label: 'Condition' }),
+
+    value: mongooseField({ type: String, label: 'Value', optional: true }),
+  },
+  { _id: false },
+);
+
+export const attachmentSchema = new Schema(
+  {
+    name: mongooseField({ type: String }),
+    url: mongooseField({ type: String }),
+    type: mongooseField({ type: String }),
+    size: mongooseField({ type: Number, optional: true }),
+    duration: mongooseField({ type: Number, optional: true }),
+  },
+  { _id: false },
+);

package/src/core-modules/common/eventHandlers/createEventHandlers.ts

@@ -0,0 +1,236 @@
+import { sendWorkerQueue } from '../../../utils/mq-worker';
+import { sendTRPCMessage } from '../../../utils/trpc';
+import { LogEventInput, LogEventSchema } from './schemas';
+import {
+  EventDispatcherReturn,
+  TLogEventPayload,
+  ICreateEventHandlersParams,
+  DbLogActions,
+  ActivityLogInput,
+} from './types';
+import {
+  generateAutomationTriggerPayload,
+  generateDbEventPayload,
+  normalizeLogEventInput,
+} from './utils';
+import { sendAutomationTrigger } from '../../automations';
+import { sendSegmentChanged } from '../../segments/events';
+import { segmentJoinChanges } from '../../segments/joinChanges';
+import { INotificationData, sendNotification } from '../../notifications';
+import { logActivityLogError } from '../../logs/activityLog/utils';
+
+/** One id or many, as the action recorded it, with the empties dropped. */
+const toIdList = (ids?: string | string[]): string[] =>
+  (Array.isArray(ids) ? ids : [ids]).filter(
+    (id): id is string => typeof id === 'string' && id.length > 0,
+  );
+
+/**
+ * Create an event dispatcher instance with methods for logging and automation triggers
+ * @param params - Configuration object for the event dispatcher
+ * @returns Event dispatcher with methods for database event logging and automation triggers
+ */
+export function createEventHandlers(
+  params: ICreateEventHandlersParams,
+): EventDispatcherReturn {
+  const { subdomain, pluginName, moduleName, collectionName, getContext } =
+    params;
+  const contentType = `${pluginName}:${moduleName}.${collectionName}`;
+
+  /**
+   * Send log event for document operations (single or bulk)
+   * @param input - Event input object with action-specific structure:
+   *   - create: { action: 'create', docId: string | string[], currentDocument: any, prevDocument?: any }
+   *   - update: { action: 'update', docId: string | string[], currentDocument: any, prevDocument: any }
+   *   - delete: { action: 'delete', docId: string }
+   *   - deleteMany: { action: 'deleteMany', docIds: string[] }
+   *   - updateMany: { action: 'updateMany', docIds: string | string[], updateDescription: Record<string, any> }
+   *   - bulkWrite: { action: 'bulkWrite', docIds: string | string[], updateDescription: Record<string, any> }
+   */
+  function sendDbEventLog(input: LogEventInput): void {
+    const normalizedInput = normalizeLogEventInput(input);
+    const parsed = LogEventSchema.parse(normalizedInput);
+    const { action } = parsed;
+
+    // Get current processId and userId dynamically each time
+    const { processId, userId } = getContext();
+
+    const queue = sendWorkerQueue('logs', 'put_log');
+    const payload = generateDbEventPayload(parsed, collectionName);
+
+    const eventPayload: TLogEventPayload = {
+      subdomain,
+      source: 'mongo',
+      action,
+      status: 'success',
+      contentType,
+      payload,
+      processId,
+      userId,
+    };
+
+    if (
+      action === DbLogActions.BULK_WRITE ||
+      action === DbLogActions.UPDATE_MANY ||
+      action === DbLogActions.DELETE_MANY
+    ) {
+      eventPayload.docIds = parsed.docIds;
+    }
+    if (
+      action === DbLogActions.CREATE ||
+      action === DbLogActions.UPDATE ||
+      action === DbLogActions.DELETE
+    ) {
+      eventPayload.docId = parsed.docId;
+    }
+
+    queue
+      .add('put_log', eventPayload, {
+        removeOnComplete: true,
+      })
+      .catch((err) => {
+        console.error('sendDbEventLog queue.add failed', err);
+      });
+    const docIds = toIdList(eventPayload.docIds ?? eventPayload.docId);
+
+    segmentJoinChanges(contentType, payload?.updateDescription)
+      .then((changed) =>
+        sendSegmentChanged({ subdomain, contentType, docIds, changed }),
+      )
+      .catch(() => sendSegmentChanged({ subdomain, contentType, docIds }));
+
+    if (action === DbLogActions.CREATE || action === DbLogActions.UPDATE) {
+      const eventUpdateDescription = payload?.updateDescription;
+      const automationTriggerPayload = generateAutomationTriggerPayload(
+        parsed,
+        contentType,
+        eventUpdateDescription,
+      );
+
+      if (automationTriggerPayload) {
+        sendAutomationTrigger(subdomain, automationTriggerPayload);
+      }
+    }
+  }
+
+  /**
+   * Send automation trigger for document changes
+   * @param params - Object with targets and recordType
+   * @param params.targets - Single document or array of documents
+   * @param params.recordType - Operation type to determine if record is 'new' or 'existing'
+   */
+  function sendAutomationTriggerTarget(params: {
+    targets: any[];
+    recordType: 'new' | 'existing';
+  }) {
+    return sendAutomationTrigger(subdomain, {
+      type: contentType,
+      targets: Array.isArray(params.targets)
+        ? params.targets
+        : [params.targets],
+      recordType: params.recordType,
+    });
+  }
+
+  /**
+   * Says what an entry happened inside of, for records nobody typed in.
+   *
+   * `createdVia` is on every schema, so this reads it once here instead of
+   * asking each module to remember. A caller that set its own context keeps
+   * it — this only fills a blank.
+   */
+  function withProvenance(
+    activity: ActivityLogInput & { contextType?: string },
+  ) {
+    const via = activity.target?.createdVia;
+
+    if (!via?.sourceId || activity.context || activity.contextType) {
+      return activity;
+    }
+
+    return {
+      ...activity,
+      contextType: via.source,
+      context: {
+        // `text` is what the feed already renders; the ids ride in `data`,
+        // which is where an activity entity keeps its own payload.
+        text: via.sourceName,
+        data: { sourceId: via.sourceId, runId: via.runId },
+      },
+    };
+  }
+
+  function createActivityLog(
+    input: ActivityLogInput | ActivityLogInput[],
+    duserId?: string,
+  ) {
+    try {
+      const { processId, userId } = getContext();
+
+      const isMultiple = Array.isArray(input);
+      const commonObj = { pluginName, moduleName, collectionName };
+
+      const getInputData = (activities: ActivityLogInput[]) =>
+        activities.map((activity) => ({
+          ...activity,
+          ...commonObj,
+        }));
+
+      const inputData = getInputData(isMultiple ? input : [input]).map(
+        withProvenance,
+      );
+
+      if (!inputData.length) {
+        return;
+      }
+
+      // Nobody was in a request when an automation wrote this, so the actor
+      // would otherwise come back empty. Whatever produced the record names
+      // the person whose configuration it was.
+      const actorId = inputData
+        .map((activity) => activity.target?.createdVia?.actorId)
+        .find(Boolean);
+
+      sendTRPCMessage({
+        subdomain,
+        pluginName: 'core',
+        method: 'mutation',
+        module: 'activityLog',
+        action: 'createActivityLog',
+        input: inputData,
+        context: {
+          processId,
+          userId: duserId || userId || actorId,
+        },
+      }).catch((error) => {
+        logActivityLogError('createActivityLog dispatch', error, {
+          subdomain,
+          pluginName,
+          moduleName,
+          collectionName,
+        });
+      });
+    } catch (error) {
+      logActivityLogError('createActivityLog setup', error, {
+        subdomain,
+        pluginName,
+        moduleName,
+        collectionName,
+      });
+    }
+  }
+
+  function sendNotificationMessage(
+    notificationData: { userIds: string[] } & Partial<INotificationData>,
+  ) {
+    sendNotification(subdomain, notificationData);
+  }
+
+  return {
+    sendDbEventLog,
+    sendAutomationTriggerTarget,
+    createActivityLog,
+    sendNotificationMessage,
+    getContext,
+  };
+}

package/src/core-modules/common/eventHandlers/generateEventHandlers.ts

@@ -0,0 +1,37 @@
+import { createEventHandlers } from './createEventHandlers';
+import { ScopedEventHandlers } from './types';
+import {
+  getEventHandlerRuntimeContext,
+  normalizeEventHandlerContext,
+} from './runtimeContext';
+
+export const createScopedEventHandlers: (
+  subdomain: string,
+  initialContext?: Record<string, any>,
+) => ScopedEventHandlers =
+  (subdomain: string, initialContext?: Record<string, any>) =>
+  (pluginName: string) =>
+  (moduleName: string, collectionName: string) => {
+    const fallbackContext = normalizeEventHandlerContext(
+      subdomain,
+      initialContext,
+    );
+
+    return createEventHandlers({
+      subdomain,
+      pluginName,
+      moduleName,
+      collectionName,
+      getContext: () => {
+        const runtimeContext = getEventHandlerRuntimeContext();
+
+        if (runtimeContext?.subdomain === subdomain) {
+          return runtimeContext;
+        }
+
+        return fallbackContext;
+      },
+    });
+  };
+
+export const generateEventHandlersFromRequest = createScopedEventHandlers;

package/src/core-modules/common/eventHandlers/index.ts

@@ -0,0 +1,11 @@
+export { createEventHandlers } from './createEventHandlers';
+export { setEventHandlerRuntimeContext } from './runtimeContext';
+export {
+  createScopedEventHandlers,
+  generateEventHandlersFromRequest,
+} from './generateEventHandlers';
+export type {
+  EventDispatcherReturn,
+  ActivityLogInput,
+  ScopedEventHandlers,
+} from './types';

package/src/core-modules/common/eventHandlers/runtimeContext.ts

@@ -0,0 +1,36 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+export type EventHandlerRuntimeContext = {
+  subdomain: string;
+  processId: string;
+  userId: string;
+};
+
+const eventHandlerContextStorage =
+  new AsyncLocalStorage<EventHandlerRuntimeContext>();
+
+export const normalizeEventHandlerContext = (
+  subdomain: string,
+  context?: Record<string, any>,
+): EventHandlerRuntimeContext => {
+  const userId = context?.userId || context?.user?._id || '';
+
+  return {
+    subdomain,
+    processId: context?.processId || '',
+    userId,
+  };
+};
+
+export const getEventHandlerRuntimeContext = () => {
+  return eventHandlerContextStorage.getStore();
+};
+
+export const setEventHandlerRuntimeContext = (
+  subdomain: string,
+  context?: Record<string, any>,
+) => {
+  eventHandlerContextStorage.enterWith(
+    normalizeEventHandlerContext(subdomain, context),
+  );
+};

package/src/core-modules/common/eventHandlers/schemas.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+
+const CreateLogSchema = z.object({
+  action: z.literal('create'),
+  docId: z.string(),
+  currentDocument: z.any(),
+  prevDocument: z.any().optional(),
+});
+
+const UpdateLogSchema = z.object({
+  action: z.literal('update'),
+  docId: z.string(),
+  currentDocument: z.any(),
+  prevDocument: z.any(),
+});
+
+const DeleteLogSchema = z.object({
+  action: z.literal('delete'),
+  docId: z.string(),
+  // The document as it was just before deletion. Optional for backward
+  // compatibility; when supplied the log records what was removed.
+  prevDocument: z.any().optional(),
+});
+
+const DeleteManyLogSchema = z.object({
+  action: z.literal('deleteMany'),
+  docIds: z.array(z.string()),
+  // Prior documents (any order; matched to docIds by _id). Optional.
+  prevDocuments: z.array(z.any()).optional(),
+});
+
+const UpdateManyLogSchema = z.object({
+  action: z.literal('updateMany'),
+  docIds: z.union([z.string(), z.array(z.string())]),
+  updateDescription: z.record(z.any()),
+});
+
+const BulkWriteLogSchema = z.object({
+  action: z.literal('bulkWrite'),
+  docIds: z.union([z.string(), z.array(z.string())]),
+  updateDescription: z.record(z.any()),
+});
+
+export const LogEventSchema = z.union([
+  CreateLogSchema,
+  UpdateLogSchema,
+  DeleteLogSchema,
+  DeleteManyLogSchema,
+  UpdateManyLogSchema,
+  BulkWriteLogSchema,
+]);
+
+export type LogEventInput = z.infer<typeof LogEventSchema>;