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

package/src/utils/apollo/expectedErrorPlugin.ts

@@ -0,0 +1,83 @@
+import type { ApolloServerPlugin, GraphQLRequestListener } from '@apollo/server';
+import { classifyError, IClassificationResult } from '../errorClassifier';
+
+/**
+ * Apollo Server plugin that handles expected errors
+ * 
+ * Features:
+ * - Overrides HTTP status to 200 when all errors are EXPECTED business errors
+ * - Adds error category metadata to GraphQL error extensions
+ * - Allows frontend to distinguish business errors from system errors
+ */
+export const expectedErrorPlugin: ApolloServerPlugin = {
+  async requestDidStart(): Promise<GraphQLRequestListener<any>> {
+    // Store classifications from didEncounterErrors to use in willSendResponse
+    const errorClassifications = new Map<string, IClassificationResult>();
+
+    return {
+      async didEncounterErrors(requestContext) {
+        // Capture original GraphQL errors with their full context
+        for (const error of requestContext.errors) {
+          const originalError = error.originalError || error;
+          const classification = classifyError(originalError);
+          
+          // Use error path as key to match in willSendResponse
+          const pathKey = error.path 
+            ? error.path.join('.') 
+            : error.message;
+          errorClassifications.set(pathKey, classification);
+        }
+      },
+
+      async willSendResponse(requestContext) {
+        const { response } = requestContext;
+        
+        // Check if response has errors
+        if (response.body.kind !== 'single' || !response.body.singleResult.errors) {
+          return;
+        }
+
+        const errors = response.body.singleResult.errors;
+        if (!errors || errors.length === 0) {
+          return;
+        }
+
+        // Classify each error using stored classifications from didEncounterErrors
+        const classifications: IClassificationResult[] = errors.map(error => {
+          const pathKey = error.path 
+            ? error.path.join('.') 
+            : error.message;
+          
+          // Use pre-computed classification from didEncounterErrors if available
+          const stored = errorClassifications.get(pathKey);
+          if (stored) {
+            return stored;
+          }
+          
+          // Fallback: classify from the formatted error message
+          return classifyError(error.message);
+        });
+
+        // Enrich error extensions with category metadata
+        errors.forEach((error, index) => {
+          const classification = classifications[index];
+          
+          if (!error.extensions) {
+            (error as any).extensions = {};
+          }
+
+          (error as any).extensions.category = classification.category;
+          (error as any).extensions.isExpected = classification.isExpected;
+          (error as any).extensions.statusCode = classification.statusCode;
+        });
+
+        // If ALL errors are expected, override HTTP status to 200
+        const allExpected = classifications.every(c => c.category === 'EXPECTED');
+        
+        if (allExpected && response.http) {
+          response.http.status = 200;
+        }
+      },
+    };
+  },
+};

package/src/utils/apollo/index.ts

@@ -0,0 +1,10 @@
+export * from './commonTypeDefs';
+export * from './constants';
+export * from './customScalars';
+export * from './utils';
+export * from './wrapperMutations';
+export * from './wrapperResolvers';
+export * from './beforeResolvers';
+export * from './runBeforeResolvers';
+export * from './expectedErrorPlugin';
+

package/src/utils/apollo/runBeforeResolvers.ts

@@ -0,0 +1,214 @@
+import { getPlugin, getPlugins } from '../service-discovery';
+import { sendCoreModuleProducer } from '../trpc/sendCoreModuleProducer';
+import { createExpectedError } from '../errorClassifier';
+import {
+  BeforeResolverBlockedResult,
+  BeforeResolversConfig,
+  BeforeResolverOkResult,
+  TBeforeResolversProducers,
+  BeforeResolverResolvedResult,
+} from './beforeResolvers';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
+const isBlockedResult = (
+  result: unknown,
+): result is BeforeResolverBlockedResult =>
+  isRecord(result) &&
+  result.status === 'blocked' &&
+  typeof result.code === 'string' &&
+  typeof result.message === 'string';
+
+const isResolvedResult = (
+  result: unknown,
+): result is BeforeResolverResolvedResult =>
+  isRecord(result) && result.status === 'resolved' && 'data' in result;
+
+
+const isOkResult = (result: unknown): result is BeforeResolverOkResult =>
+  isRecord(result) && result.status === 'ok';
+
+const mergeBeforeResolverArgs = (
+  args: Record<string, unknown>,
+  result: unknown,
+): Record<string, unknown> => {
+  if (isOkResult(result)) {
+    return isRecord(result.args) ? { ...args, ...result.args } : args;
+  }
+
+  if (isRecord(result)) {
+    return { ...args, ...result };
+  }
+
+  return args;
+};
+
+export type BeforeResolverCheckBlockedResult = BeforeResolverBlockedResult & {
+  pluginName: string;
+};
+
+export type BeforeResolverCheckResult = {
+  available: boolean;
+  args: Record<string, unknown>;
+  blocked: BeforeResolverCheckBlockedResult[];
+};
+
+const pluginHandlesResolver = (
+  config: BeforeResolversConfig | undefined,
+  resolverName: string,
+): boolean => {
+  if (!config?.resolvers) {
+    return false;
+  }
+
+  for (const moduleName of Object.keys(config.resolvers)) {
+    if ((config.resolvers[moduleName] || []).includes(resolverName)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export type BeforeResolverRunResult =
+  | { resolved: false; args: Record<string, unknown> }
+  | { resolved: true; data: unknown };
+
+export const runBeforeResolvers = async (
+  resolverName: string,
+  args: Record<string, unknown>,
+  context: {
+    subdomain: string;
+    user?: unknown;
+    headers?: Record<string, string | string[] | undefined>;
+  },
+): Promise<BeforeResolverRunResult> => {
+  const pluginNames = await getPlugins();
+
+  let mergedArgs = args;
+
+  for (const pluginName of pluginNames) {
+    const plugin = await getPlugin(pluginName);
+    const config: BeforeResolversConfig | undefined =
+      plugin?.config?.meta?.beforeResolvers;
+
+    if (!pluginHandlesResolver(config, resolverName)) {
+      continue;
+    }
+
+    const blockResult: unknown = await sendCoreModuleProducer({
+      subdomain: context.subdomain,
+      pluginName,
+      moduleName: 'beforeResolvers',
+      producerName: TBeforeResolversProducers.BLOCKER,
+      method: 'query',
+      input: {
+        resolver: resolverName,
+        args: mergedArgs,
+        user: context.user,
+        headers: context.headers,
+      },
+    });
+
+    if (isBlockedResult(blockResult)) {
+      throw createExpectedError(blockResult.message, blockResult.code);
+    }
+
+    const result: unknown = await sendCoreModuleProducer({
+      subdomain: context.subdomain,
+      pluginName,
+      moduleName: 'beforeResolvers',
+      producerName: TBeforeResolversProducers.HANDLE,
+      input: {
+        resolver: resolverName,
+        args: mergedArgs,
+        user: context.user,
+        headers: context.headers,
+      },
+    });
+
+    if (isBlockedResult(result)) {
+      throw createExpectedError(result.message, result.code);
+    }
+
+    if (isResolvedResult(result)) {
+      return { resolved: true, data: result.data };
+    }
+
+    mergedArgs = mergeBeforeResolverArgs(mergedArgs, result);
+  }
+
+  return { resolved: false, args: mergedArgs };
+};
+
+export const checkBeforeResolvers = async (
+  resolverName: string,
+  args: Record<string, unknown>,
+  context: {
+    subdomain: string;
+    user?: unknown;
+    headers?: Record<string, string | string[] | undefined>;
+  },
+): Promise<BeforeResolverCheckResult> => {
+  const pluginNames = await getPlugins();
+
+  let mergedArgs = args;
+  const blocked: BeforeResolverCheckBlockedResult[] = [];
+
+  for (const pluginName of pluginNames) {
+    const plugin = await getPlugin(pluginName);
+    const config: BeforeResolversConfig | undefined =
+      plugin?.config?.meta?.beforeResolvers;
+
+    if (!pluginHandlesResolver(config, resolverName)) {
+      continue;
+    }
+
+    const blockResult: unknown = await sendCoreModuleProducer({
+      subdomain: context.subdomain,
+      pluginName,
+      moduleName: 'beforeResolvers',
+      producerName: TBeforeResolversProducers.BLOCKER,
+      method: 'query',
+      input: {
+        resolver: resolverName,
+        args: mergedArgs,
+        user: context.user,
+        headers: context.headers,
+      },
+    });
+
+    if (isBlockedResult(blockResult)) {
+      blocked.push({ ...blockResult, pluginName });
+      continue;
+    }
+
+    const result: unknown = await sendCoreModuleProducer({
+      subdomain: context.subdomain,
+      pluginName,
+      moduleName: 'beforeResolvers',
+      producerName: TBeforeResolversProducers.CHECK,
+      method: 'query',
+      input: {
+        resolver: resolverName,
+        args: mergedArgs,
+        user: context.user,
+        headers: context.headers,
+      },
+    });
+
+    if (isBlockedResult(result)) {
+      blocked.push({ ...result, pluginName });
+      continue;
+    }
+
+    mergedArgs = mergeBeforeResolverArgs(mergedArgs, result);
+  }
+
+  return {
+    available: blocked.length === 0,
+    args: mergedArgs,
+    blocked,
+  };
+};

package/src/utils/apollo/utils.ts

@@ -0,0 +1,80 @@
+import { ExpressContextFunctionArgument } from '@apollo/server/dist/esm/express4';
+import { Request as ApiRequest, Response as ApiResponse } from 'express';
+import { IMainContext } from '../../core-types';
+import {
+  extractCPUserFromHeader,
+  extractClientPortalFromHeader,
+  extractUserFromHeader,
+} from '../headers';
+import { generateRequestProcess, getSubdomain } from '../utils';
+import { createScopedEventHandlers } from '../../core-modules/common/eventHandlers/generateEventHandlers';
+import { setEventHandlerRuntimeContext } from '../../core-modules/common/eventHandlers/runtimeContext';
+import { checkPermissionGroup } from '../../core-modules/permissions/utils';
+
+export const generateApolloContext =
+  <TContext>(
+    apolloServerContext: (
+      subdomain: string,
+      context: IMainContext,
+      req: ApiRequest,
+      res: ApiResponse,
+    ) => Promise<TContext>,
+  ) =>
+  async ({ req, res }: ExpressContextFunctionArgument) => {
+    if (
+      req.body.operationName === 'IntrospectionQuery' ||
+      req.body.operationName === 'SubgraphIntrospectQuery'
+    ) {
+      return {};
+    }
+
+    const user: any = extractUserFromHeader(req.headers);
+    const cpUser: any = extractCPUserFromHeader(req.headers);
+    const clientPortal: any = extractClientPortalFromHeader(req.headers);
+
+    const subdomain = getSubdomain(req);
+
+    // Honor a caller-supplied correlation id (e.g. the AI agent stamps each
+    // action) so a request's DB changes can be traced together; the
+    // router propagates this header to every subgraph. Falls back to a fresh id.
+    const incomingProcessId = req.headers['x-erxes-process-id'];
+    const processInfo = generateRequestProcess(
+      Array.isArray(incomingProcessId)
+        ? incomingProcessId[0]
+        : incomingProcessId,
+    );
+
+    const __ = (doc: any) => ({ ...processInfo, ...doc });
+    setEventHandlerRuntimeContext(subdomain, {
+      subdomain,
+      processId: processInfo.processId || '',
+      userId: user?._id || '',
+    });
+
+    const context = {
+      user,
+      cpUser,
+      clientPortal,
+      req,
+      res,
+      subdomain,
+      __,
+      ...processInfo,
+      requestInfo: {
+        secure: req.secure,
+        cookies: req.cookies,
+      },
+      eventHandlers: createScopedEventHandlers(subdomain, {
+        subdomain,
+        processId: processInfo.processId || '',
+        userId: user?._id || '',
+      }),
+      checkPermission: checkPermissionGroup(subdomain, user),
+    };
+
+    if (apolloServerContext) {
+      return await apolloServerContext(subdomain, context, req, res);
+    }
+
+    return context;
+  };

package/src/utils/apollo/wrapperMutations.ts

@@ -0,0 +1,75 @@
+import { IMainContext } from '../../core-types';
+import { GraphQLResolveInfo } from 'graphql';
+import { logHandler } from '../logs';
+import { runBeforeResolvers } from './runBeforeResolvers';
+
+type GraphqlLogHandler<TArgs = any, TReturn = any> = (
+  root: any,
+  args: TArgs,
+  context: { subdomain: string } & IMainContext,
+  info: GraphQLResolveInfo,
+) => Promise<TReturn> | TReturn;
+
+const withLogging = (resolver: GraphqlLogHandler): GraphqlLogHandler => {
+  return async (root, args, context, info) => {
+    const { user, req, processId, subdomain } = context;
+    const requestData = req.headers;
+
+    return await logHandler(
+      async () => await resolver(root, args, context, info),
+      {
+        subdomain,
+        source: 'graphql',
+        action: 'mutation',
+        payload: {
+          mutationName: info.fieldName,
+          requestData,
+          args,
+        },
+        processId,
+        userId: user?._id,
+      },
+    );
+  };
+};
+
+const withBefore = (
+  resolver: GraphqlLogHandler,
+  resolverKey: string,
+): GraphqlLogHandler => {
+  return async (root, args, context, info) => {
+    const { subdomain, user } = context;
+
+    const headers = (context as any).requestInfo?.headers || (context as any).req?.headers;
+
+    const result = await runBeforeResolvers(resolverKey, args, {
+      subdomain,
+      user,
+      headers,
+    });
+
+    if (result.resolved) {
+      return result.data;
+    }
+
+    return resolver(root, result.args, context, info);
+  };
+};
+
+// Apply middleware to all mutations in an object
+export const wrapApolloMutations = (
+  mutations: Record<string, GraphqlLogHandler>,
+  muataionsForSkip?: string[],
+) => {
+  const wrappedMutations: Record<string, GraphqlLogHandler> = {};
+
+  for (const [key, resolver] of Object.entries(mutations)) {
+    if (muataionsForSkip?.includes(key)) {
+      wrappedMutations[key] = resolver;
+    } else {
+      wrappedMutations[key] = withLogging(withBefore(resolver, key));
+    }
+  }
+
+  return wrappedMutations;
+};

package/src/utils/apollo/wrapperResolvers.ts

@@ -0,0 +1,182 @@
+import * as Sentry from '@sentry/node';
+import {
+  wrapPermission,
+  wrapPublicResolver,
+} from '../../core-modules/permissions/utils';
+import {
+  IMainContext,
+  IResolverSymbol,
+  Resolver,
+} from '../../core-types/common';
+import { logHandler } from '../logs';
+import { runBeforeResolvers } from './runBeforeResolvers';
+import { classifyError } from '../errorClassifier';
+
+const withSentryCapture = (
+  resolver: Resolver,
+  resolverKey: string,
+  operation: 'query' | 'mutation',
+): Resolver => {
+  return async (root, args, context, info) => {
+    try {
+      return await resolver(root, args, context, info);
+    } catch (err) {
+      const classification = classifyError(err);
+
+      // Only capture system/provider errors in Sentry
+      // Expected business errors (not found, validation, etc.) are skipped
+      if (classification.category !== 'EXPECTED') {
+        Sentry.withScope((scope) => {
+          scope.setTag('graphql.operation', operation);
+          scope.setTag('graphql.field', resolverKey);
+          scope.setTag('error.category', classification.category);
+          scope.setContext('graphql', {
+            field: resolverKey,
+            operation,
+            subdomain: context?.subdomain,
+            userId: context?.user?._id,
+            errorCategory: classification.category,
+          });
+          Sentry.captureException(err);
+        });
+      }
+
+      throw err;
+    }
+  };
+};
+
+const withBeforeResolvers = (
+  resolver: Resolver,
+  resolverKey: string,
+): Resolver => {
+  return async (root, args, context, info) => {
+    const { subdomain, user } = context;
+
+    const headers = (context as any).requestInfo?.headers || (context as any).req?.headers;
+
+    const result = await runBeforeResolvers(resolverKey, args, {
+      subdomain,
+      user,
+      headers,
+    });
+
+    if (result.resolved) {
+      return result.data;
+    }
+
+    return resolver(root, result.args, context, info);
+  };
+};
+
+const withLogging = (resolver: Resolver): Resolver => {
+  return async (root, args, context, info) => {
+    const { user, req, processId, subdomain } = context;
+    const requestData = req.headers;
+
+    return await logHandler(
+      async () => await resolver(root, args, context, info),
+      {
+        subdomain,
+        source: 'graphql',
+        action: 'mutation',
+        payload: {
+          mutationName: info.fieldName,
+          requestData,
+          args,
+        },
+        processId,
+        userId: user?._id,
+      },
+    );
+  };
+};
+
+export const wrapApolloResolvers = (resolvers: Record<string, Resolver>) => {
+  const wrappedResolvers: any = {};
+
+  for (const [key, resolver] of Object.entries(resolvers)) {
+    if (key === 'Mutation') {
+      const mutationResolvers: any = {};
+
+      for (const [mutationKey, mutationResolver] of Object.entries(resolver)) {
+        const { skipPermission, cpUserRequired, forClientPortal } =
+          mutationResolver.wrapperConfig || {};
+        const isPublic = skipPermission || forClientPortal || cpUserRequired;
+
+        let wrapped: Resolver;
+        if (isPublic) {
+          wrapped = wrapPublicResolver(
+            withBeforeResolvers(mutationResolver, mutationKey),
+            mutationResolver.wrapperConfig,
+          );
+        } else {
+          wrapped = withLogging(
+            wrapPermission(
+              withBeforeResolvers(mutationResolver, mutationKey),
+              mutationKey,
+            ),
+          );
+        }
+
+        mutationResolvers[mutationKey] = withSentryCapture(
+          wrapped,
+          mutationKey,
+          'mutation',
+        );
+      }
+
+      wrappedResolvers[key] = mutationResolvers;
+      continue;
+    }
+
+    if (key === 'Query') {
+      const queryResolvers: any = {};
+
+      for (const [queryKey, queryResolver] of Object.entries(resolver)) {
+        const { skipPermission, cpUserRequired, forClientPortal } =
+          queryResolver.wrapperConfig || {};
+        const isPublic = skipPermission || forClientPortal || cpUserRequired;
+
+        let wrapped: Resolver;
+        if (isPublic) {
+          wrapped = wrapPublicResolver(
+            withBeforeResolvers(queryResolver, queryKey),
+            queryResolver.wrapperConfig,
+          );
+        } else {
+          wrapped = wrapPermission(
+            withBeforeResolvers(queryResolver, queryKey),
+            queryKey,
+          );
+        }
+
+        queryResolvers[queryKey] = withSentryCapture(
+          wrapped,
+          queryKey,
+          'query',
+        );
+      }
+
+      wrappedResolvers[key] = queryResolvers;
+      continue;
+    }
+
+    wrappedResolvers[key] = resolver;
+  }
+
+  return wrappedResolvers;
+};
+type TResolverMap<TContext = any> = Record<
+  string,
+  Resolver<any, any, TContext & { subdomain: string } & IMainContext, any>
+>;
+
+export const markResolvers = <TContext = any>(
+  resolvers: TResolverMap<TContext>,
+  symbols: IResolverSymbol,
+) => {
+  for (const key in resolvers) {
+    resolvers[key] = Object.assign(resolvers[key], symbols);
+  }
+};

package/src/utils/bulkUtils.ts

@@ -0,0 +1,62 @@
+import { chunkArray } from './utils';
+import { Readable, Transform } from 'stream';
+
+export const stream = async <T>(
+  executeChunk: (chunk: T[]) => Promise<void>,
+  transformCallback: (variables: { parentIds?: T[] }, root: T) => void,
+  generateChildStream: () => { cursor: () => Readable },
+  chunkSize: number,
+): Promise<'done'> => {
+  const variables: { parentIds?: T[] } = {};
+
+  // Function to handle remaining items after streaming
+  const onFinishPiping = async () => {
+    if (variables.parentIds && variables.parentIds.length > 0) {
+      const chunks = chunkArray(variables.parentIds, chunkSize);
+      for (const chunk of chunks) {
+        await executeChunk(chunk);
+      }
+    }
+  };
+
+  // Transformer stream to process each item
+  const parentTransformerStream = new Transform({
+    objectMode: true,
+    transform(root: unknown, _encoding, callback) {
+      try {
+        transformCallback(variables, root as T);
+        callback();
+      } catch (err) {
+        callback(err as Error);
+      }
+    },
+  });
+
+  const childCursor = generateChildStream().cursor();
+
+  try {
+    await new Promise<void>((resolve, reject) => {
+      childCursor.pipe(parentTransformerStream);
+
+      parentTransformerStream.on('finish', async () => {
+        try {
+          await onFinishPiping();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+
+      parentTransformerStream.on('error', reject);
+    });
+
+    return 'done';
+  } catch (error) {
+    parentTransformerStream.destroy();
+    throw error;
+  } finally {
+    if (typeof childCursor.destroy === 'function') {
+      childCursor.destroy();
+    }
+  }
+};