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

package/src/core-modules/automations/workflowValidation.ts

@@ -0,0 +1,32 @@
+import {
+  IAutomationAction,
+  IAutomationWorkflow,
+} from './definitions/automations';
+
+const ACTION_REF_REGEX = /\{\{\s*actions\.([^.\s{}]+)/;
+
+// Problems that must block activating an automation: workflow input bindings
+// referencing actions that don't exist in the automation.
+export const validateWorkflowBindings = (
+  workflows: IAutomationWorkflow[] = [],
+  actions: IAutomationAction[] = [],
+) => {
+  const actionIds = new Set(actions.map(({ id }) => id));
+  const errors: string[] = [];
+
+  for (const workflow of workflows) {
+    for (const [name, expression] of Object.entries(
+      workflow.config?.inputs || {},
+    )) {
+      const actionRef = String(expression).match(ACTION_REF_REGEX);
+
+      if (actionRef && !actionIds.has(actionRef[1])) {
+        errors.push(
+          `Workflow "${workflow.name}": input "${name}" references missing action "${actionRef[1]}"`,
+        );
+      }
+    }
+  }
+
+  return errors;
+};

package/src/core-modules/automations/zodTypes.ts

@@ -0,0 +1,221 @@
+import { z } from 'zod';
+import { TAutomationProducers } from './types';
+
+export const AutomationBaseInput = z.object({
+  subdomain: z.string(),
+  data: z.any().optional(),
+});
+
+export const AutomationExecActionInput = z.object({
+  createdAt: z.string().optional(),
+  startedAt: z.string().optional(),
+  finishedAt: z.string().optional(),
+  durationMs: z.number().optional(),
+  status: z
+    .enum([
+      'success',
+      'skipped',
+      'error',
+      'waiting',
+      'queued',
+      'standby',
+      'dropped',
+    ])
+    .optional(),
+  actionId: z.string(),
+  actionType: z.string(),
+  actionConfig: z.any().optional(),
+  nextActionId: z.string().optional(),
+  result: z.any().optional(),
+  skipReason: z.string().optional(),
+  attempt: z.number().optional(),
+  jobId: z.string().optional(),
+  // Dates arrive serialized across the producer boundary, but stay Date
+  // objects when the execution is passed in-process.
+  queuedAt: z.union([z.string(), z.date()]).optional(),
+  expiresAt: z.union([z.string(), z.date()]).optional(),
+});
+
+export const AutomationExecutionInput = z.object({
+  _id: z.string(),
+  createdAt: z.string().optional(),
+  modifiedAt: z.string().optional(),
+  automationId: z.string(),
+  triggerId: z.string(),
+  triggerType: z.string(),
+  // A trigger that was never configured stores no config at all — Mongoose
+  // drops an empty object on a Mixed path — so an execution legitimately
+  // arrives without one. Defaulted rather than required, or every plugin
+  // action behind such a trigger fails before it runs.
+  triggerConfig: z.record(z.any()).optional().default({}),
+  nextActionId: z.string().optional(),
+  targetId: z.string(),
+  target: z.record(z.any()),
+  // Stripped by the parse unless it is declared, and a plugin that creates
+  // records on someone's behalf has no other way to know whose.
+  createdVia: z
+    .object({
+      source: z.string(),
+      sourceId: z.string(),
+      sourceName: z.string().optional(),
+      runId: z.string().optional(),
+      actorId: z.string().optional(),
+    })
+    .optional(),
+  status: z.string(),
+  description: z.string(),
+  actions: z.array(AutomationExecActionInput).optional(),
+  startWaitingDate: z.coerce.date().optional(),
+  waitingActionId: z.string().optional(),
+  objToCheck: z.record(z.any()).optional(),
+  responseActionId: z.string().optional(),
+});
+
+export const AutomationActionInput = z.object({
+  id: z.string(),
+  type: z.string(),
+  nextActionId: z.string().optional(),
+  config: z.any().optional(),
+  style: z.any(),
+  icon: z.string().optional(),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  workflowId: z.string().optional(),
+  targetActionId: z.string().optional(),
+});
+
+export const ReceiveActionsInputData = z.object({
+  moduleName: z.string(),
+  actionType: z.string(),
+  action: AutomationActionInput,
+  execution: AutomationExecutionInput,
+  collectionType: z.string(),
+  // What the trigger declared it gives this action (see `actionInputs`).
+  inputs: z.record(z.any()).optional(),
+});
+export const ReceiveActionsInput = AutomationBaseInput.extend({
+  data: ReceiveActionsInputData,
+});
+
+export const CheckCustomTriggerInputData = z.object({
+  moduleName: z.string(),
+  collectionType: z.string(),
+  relationType: z.string().optional(),
+  automationId: z.string(),
+  trigger: z.object({
+    id: z.string(),
+    type: z.string(),
+    config: z.record(z.any()),
+    actionId: z.string().optional(),
+    style: z.any().optional(),
+    icon: z.string().optional(),
+    label: z.string().optional(),
+    description: z.string().optional(),
+    isCustom: z.boolean().optional(),
+    workflowId: z.string().optional(),
+  }),
+  target: z.record(z.any()),
+  config: z.record(z.any()),
+  eventUpdateDescription: z.record(z.string(), z.any()).optional(),
+});
+
+export const FindObjectInputData = z.object({
+  objectType: z.string(),
+  field: z.string(),
+  value: z.string(),
+});
+
+export const ResolveOutputPathsInputData = z.object({
+  nodeType: z.string(),
+  source: z.record(z.any()),
+  paths: z.array(z.string()),
+  defaultValue: z.any().optional(),
+});
+
+export const SetPropertiesInputData = z.object({
+  moduleName: z.string(),
+  triggerType: z.string(),
+  targetType: z.string(),
+  actionType: z.string(),
+  action: AutomationActionInput,
+  execution: AutomationExecutionInput,
+  collectionType: z.string(),
+});
+
+export const GenerateAiContextInputData = z.object({
+  moduleName: z.string(),
+  collectionType: z.string().optional(),
+  triggerType: z.string(),
+  target: z.record(z.any()),
+});
+
+export const LoadAiKnowledgeDocumentBatchInputData = z.object({
+  moduleName: z.string(),
+  sourceKey: z.string(),
+  // 'all' means the whole source, so providers must not require a filter.
+  scope: z.enum(['all', 'selected']).optional(),
+  sourceIds: z.array(z.string()).max(1000).optional(),
+  candidateSourceIds: z.array(z.string()).max(1000).optional(),
+  config: z.record(z.unknown()).optional(),
+  cursor: z.string().optional(),
+  limit: z.number().int().min(1).max(5000).optional(),
+  skipTotalCount: z.boolean().optional(),
+});
+
+export const LookupAiToolInputData = z.object({
+  moduleName: z.string(),
+  toolKey: z.string(),
+  query: z.string().default(''),
+  limit: z.number().int().min(1).max(20).optional(),
+  filters: z.record(z.unknown()).optional(),
+});
+
+export const CheckCustomTriggerInput = AutomationBaseInput.extend({
+  data: CheckCustomTriggerInputData,
+});
+
+export const FindObjectInput = AutomationBaseInput.extend({
+  data: FindObjectInputData,
+});
+
+export const ResolveOutputPathsInput = AutomationBaseInput.extend({
+  data: ResolveOutputPathsInputData,
+});
+
+export const SetPropertiesInput = AutomationBaseInput.extend({
+  data: SetPropertiesInputData,
+});
+
+export const GenerateAiContextInput = AutomationBaseInput.extend({
+  data: GenerateAiContextInputData,
+});
+
+export const LoadAiKnowledgeDocumentBatchInput = AutomationBaseInput.extend({
+  data: LoadAiKnowledgeDocumentBatchInputData,
+});
+
+export const LookupAiToolInput = AutomationBaseInput.extend({
+  data: LookupAiToolInputData,
+});
+
+export type TAutomationProducersInput = {
+  [TAutomationProducers.RECEIVE_ACTIONS]: z.infer<
+    typeof ReceiveActionsInputData
+  >;
+  [TAutomationProducers.CHECK_CUSTOM_TRIGGER]: z.infer<
+    typeof CheckCustomTriggerInputData
+  >;
+  [TAutomationProducers.FIND_OBJECT]: z.infer<typeof FindObjectInputData>;
+  [TAutomationProducers.RESOLVE_OUTPUT_PATHS]: z.infer<
+    typeof ResolveOutputPathsInputData
+  >;
+  [TAutomationProducers.SET_PROPERTIES]: z.infer<typeof SetPropertiesInputData>;
+
+  [TAutomationProducers.GENERATE_AI_CONTEXT]: z.infer<
+    typeof GenerateAiContextInputData
+  >;
+  [TAutomationProducers.LOAD_AI_KNOWLEDGE_DOCUMENT_BATCH]: z.infer<
+    typeof LoadAiKnowledgeDocumentBatchInputData
+  >;
+  [TAutomationProducers.LOOKUP_AI_TOOL]: z.infer<typeof LookupAiToolInputData>;
+};

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

@@ -0,0 +1,230 @@
+import { Schema } from 'mongoose';
+import { mongooseStringRandomId } from '../../../utils';
+
+const otpEmailConfigSchema = new Schema(
+  {
+    emailSubject: { type: String },
+    messageTemplate: { type: String, required: true },
+    codeLength: { type: Number, required: true },
+    duration: { type: Number, required: true },
+    enableEmailVerification: { type: Boolean },
+    enablePasswordlessLogin: { type: Boolean },
+  },
+  { _id: false },
+);
+
+const otpSMSConfigSchema = new Schema(
+  {
+    messageTemplate: { type: String, required: true },
+    codeLength: { type: Number, required: true },
+    smsProvider: { type: String, required: true },
+    duration: { type: Number, required: true },
+    enablePhoneVerification: { type: Boolean },
+    enablePasswordlessLogin: { type: Boolean },
+  },
+  { _id: false },
+);
+
+const otpConfigSchema = new Schema(
+  {
+    email: { type: otpEmailConfigSchema },
+    sms: { type: otpSMSConfigSchema },
+  },
+  { _id: false },
+);
+
+const multiFactorConfigSchema = new Schema(
+  {
+    isEnabled: { type: Boolean, required: true },
+    email: { type: otpEmailConfigSchema },
+    sms: { type: otpSMSConfigSchema },
+  },
+  { _id: false },
+);
+
+const otpResendConfigSchema = new Schema(
+  {
+    cooldownPeriodInSeconds: { type: Number },
+    maxAttemptsPerHour: { type: Number },
+  },
+  { _id: false },
+);
+
+const resetPasswordConfigSchema = new Schema(
+  {
+    mode: {
+      type: String,
+      required: true,
+      enum: ['link', 'code'],
+    },
+    emailSubject: { type: String, required: true },
+    emailContent: { type: String, required: true },
+  },
+  { _id: false },
+);
+
+const authConfigSchema = new Schema(
+  {
+    accessTokenExpirationInDays: {
+      type: Number,
+    },
+    refreshTokenExpirationInDays: {
+      type: Number,
+    },
+    deliveryMethod: {
+      type: String,
+      enum: ['cookie', 'header'],
+    },
+  },
+  { _id: false },
+);
+
+const googleOAuthConfigSchema = new Schema(
+  {
+    credentials: { type: String },
+    clientId: { type: String },
+    clientSecret: { type: String },
+    redirectUri: { type: String },
+  },
+  { _id: false },
+);
+
+const facebookOAuthConfigSchema = new Schema(
+  {
+    appId: { type: String },
+    appSecret: { type: String },
+    redirectUri: { type: String },
+  },
+  { _id: false },
+);
+
+const socialpayConfigSchema = new Schema(
+  {
+    enableSocialpay: { type: Boolean },
+    publicKey: { type: String, required: true },
+    certId: { type: String, required: true },
+  },
+  { _id: false },
+);
+
+const tokiConfigSchema = new Schema(
+  {
+    enableToki: { type: Boolean },
+    merchantId: { type: String, required: true },
+    apiKey: { type: String, required: true },
+    username: { type: String, required: true },
+    password: { type: String, required: true },
+    production: { type: Boolean },
+  },
+  { _id: false },
+);
+
+const callProConfigSchema = new Schema(
+  {
+    phone: { type: String },
+    token: { type: String },
+  },
+  { _id: false },
+);
+
+const twilioConfigSchema = new Schema(
+  {
+    apiKey: { type: String },
+    apiSecret: { type: String },
+    apiUrl: { type: String },
+  },
+  { _id: false },
+);
+
+const smsProvidersConfigSchema = new Schema(
+  {
+    callPro: { type: callProConfigSchema },
+    twilio: { type: twilioConfigSchema },
+  },
+  { _id: false },
+);
+
+const verificationConfigSchema = new Schema(
+  {
+    type: {
+      type: String,
+      enum: ['email', 'phone', 'both', 'none'],
+    },
+  },
+  { _id: false },
+);
+
+const manualVerificationConfigSchema = new Schema(
+  {
+    userIds: { type: [String], required: true },
+    verifyCustomer: { type: Boolean, required: true },
+    verifyCompany: { type: Boolean, required: true },
+  },
+  { _id: false },
+);
+
+const testUserSchema = new Schema(
+  {
+    enableTestUser: { type: Boolean },
+    email: { type: String },
+    phone: { type: String },
+    password: { type: String },
+    otp: { type: Number },
+  },
+  { _id: false },
+);
+
+const firebaseConfigSchema = new Schema(
+  {
+    serviceAccountKey: { type: String }, // JSON string of Firebase service account credentials
+    enabled: { type: Boolean, default: false }, // Enable/disable Firebase notifications
+  },
+  { _id: false },
+);
+
+const authSchema = new Schema(
+  {
+    authConfig: { type: authConfigSchema },
+    googleOAuth: { type: googleOAuthConfigSchema },
+    facebookOAuth: { type: facebookOAuthConfigSchema },
+    socialpayConfig: { type: socialpayConfigSchema },
+    tokiConfig: { type: tokiConfigSchema },
+  },
+  { _id: false },
+);
+
+const securityAuthConfigSchema = new Schema(
+  {
+    otpConfig: { type: otpConfigSchema },
+    multiFactorConfig: { type: multiFactorConfigSchema },
+    otpResendConfig: { type: otpResendConfigSchema },
+    resetPasswordConfig: { type: resetPasswordConfigSchema },
+  },
+  { _id: false },
+);
+
+export const clientPortalSchema = new Schema(
+  {
+    _id: mongooseStringRandomId,
+    name: { type: String },
+    description: { type: String },
+    url: { type: String },
+    domain: { type: String },
+    token: { type: String, unique: true, sparse: true },
+    erxesIntegrationToken: { type: String },
+
+    auth: { type: authSchema },
+    securityAuthConfig: { type: securityAuthConfigSchema },
+    smsProvidersConfig: { type: smsProvidersConfigSchema },
+    verificationConfig: { type: verificationConfigSchema },
+    manualVerificationConfig: {
+      type: manualVerificationConfigSchema,
+    },
+    enableManualVerification: { type: Boolean },
+    useB2B: { type: Boolean },
+    testUser: { type: testUserSchema },
+    firebaseConfig: { type: firebaseConfigSchema },
+  },
+
+  { timestamps: true },
+);

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

@@ -0,0 +1,26 @@
+import { Schema } from 'mongoose';
+
+import { mongooseStringRandomId } from '../../../utils';
+
+export const USER_TYPES = {
+  TEAM: 'team',
+  CLIENT: 'client',
+  ALL: ['team', 'client']
+};
+
+export const commentSchema = new Schema(
+  {
+    _id: mongooseStringRandomId,
+
+    phone: { type: String, sparse: true },
+    typeId: ({ type: String, label: 'Type Id' }),
+    type: ({ type: String, label: 'Type' }),
+    content: { type: String, label: 'Content' },
+    parentId: { type: String, label: 'Parent Id' },
+    userId: { type: String, label: 'User Id' },
+    userType: { type: String, enum: USER_TYPES.ALL, label: 'User Type' },
+    createdAt: { type: Date, label: 'Created at' }
+  },
+  { timestamps: true },
+);
+commentSchema.index({ typeId: 1 });

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

@@ -0,0 +1,112 @@
+import { Schema, Document } from 'mongoose';
+import { mongooseStringRandomId } from '../../../utils';
+
+export interface ICPNotificationDocument extends Document {
+  _id: string;
+  cpUserId: string;
+  clientPortalId: string;
+  title: string;
+  message: string;
+  type: 'info' | 'success' | 'warning' | 'error';
+  contentType?: string;
+  contentTypeId?: string;
+  isRead: boolean;
+  readAt?: Date;
+  priority: 'low' | 'medium' | 'high' | 'urgent';
+  priorityLevel: 1 | 2 | 3 | 4;
+  metadata?: any;
+  action?: string;
+  kind: 'system' | 'user';
+  /** Result of sending push: which platforms had FCM tokens */
+  result?: {
+    ios?: boolean;
+    android?: boolean;
+    web?: boolean;
+  };
+  createdAt: Date;
+  expiresAt?: Date;
+  updatedAt: Date;
+}
+
+export const cpNotificationSchema = new Schema(
+  {
+    _id: mongooseStringRandomId,
+    cpUserId: {
+      type: String,
+      required: true,
+      index: true,
+    },
+    clientPortalId: {
+      type: String,
+      required: true,
+      index: true,
+    },
+    title: {
+      type: String,
+      required: true,
+      maxlength: 200,
+    },
+    message: {
+      type: String,
+      required: true,
+      maxlength: 1000,
+    },
+    type: {
+      type: String,
+      enum: ['info', 'success', 'warning', 'error'],
+      required: true,
+      default: 'info',
+    },
+    contentType: {
+      type: String,
+    },
+    contentTypeId: {
+      type: String,
+    },
+    isRead: {
+      type: Boolean,
+      default: false,
+      index: true,
+    },
+    readAt: {
+      type: Date,
+    },
+    priority: {
+      type: String,
+      enum: ['low', 'medium', 'high', 'urgent'],
+      default: 'medium',
+    },
+    priorityLevel: {
+      type: Number,
+      enum: [1, 2, 3, 4],
+      default: 2,
+      required: true,
+    },
+    metadata: {
+      type: Schema.Types.Mixed,
+    },
+    action: {
+      type: String,
+      index: true,
+    },
+    kind: {
+      type: String,
+      enum: ['system', 'user'],
+      default: 'user',
+      index: true,
+    },
+    result: {
+      ios: { type: Boolean },
+      android: { type: Boolean },
+      web: { type: Boolean },
+    },
+    expiresAt: {
+      type: Date,
+    },
+  },
+  { timestamps: true },
+);
+
+cpNotificationSchema.index({ cpUserId: 1, createdAt: -1 });
+cpNotificationSchema.index({ clientPortalId: 1, cpUserId: 1, isRead: 1 });
+cpNotificationSchema.index({ contentType: 1, contentTypeId: 1, cpUserId: 1 });