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

package/src/utils/trpc/index.ts

@@ -0,0 +1,278 @@
+import { createScopedEventHandlers } from '../../core-modules/common/eventHandlers/generateEventHandlers';
+import {
+  createTRPCUntypedClient,
+  httpBatchLink,
+  TRPCRequestOptions,
+} from '@trpc/client';
+import * as trpcExpress from '@trpc/server/adapters/express';
+import { IncomingHttpHeaders } from 'http';
+import { getPlugin, isEnabled } from '../service-discovery';
+import { generateRequestProcess, getEnv } from '../utils';
+import { setEventHandlerRuntimeContext } from '../../core-modules/common/eventHandlers/runtimeContext';
+
+export type MessageProps = {
+  subdomain: string;
+  method?: 'query' | 'mutation';
+  pluginName: string;
+  module: string;
+  action: string;
+  input: any;
+  defaultValue?: any;
+  options?: TRPCRequestOptions;
+  context?: CommonTRPCContext;
+  throwOnError?: boolean;
+};
+
+export type CommonTRPCContext = {
+  processId?: string;
+  userId?: string;
+  cpUserId?: string;
+};
+
+export type ScopedEventHandlers = ReturnType<typeof createScopedEventHandlers>;
+
+type RequestTRPCContext = {
+  subdomain: string;
+} & CommonTRPCContext;
+
+export type TRPCContext = RequestTRPCContext & {
+  eventHandlers: ScopedEventHandlers;
+};
+
+export interface InterMessage {
+  subdomain: string;
+  data?: any;
+  timeout?: number;
+  defaultValue?: any;
+  thirdService?: boolean;
+}
+
+export interface RPSuccess {
+  status: 'success';
+  data?: any;
+}
+export interface RPError {
+  status: 'error';
+  errorMessage: string;
+}
+export type RPResult = RPSuccess | RPError;
+export type RP = (params: InterMessage) => RPResult | Promise<RPResult>;
+
+export const trpcContextHeaderName = 'x-trpc-context';
+
+export function encodeTRPCContextHeader(
+  subdomain: string,
+  method: 'query' | 'mutation',
+  context: CommonTRPCContext | undefined,
+): string {
+  const contextData = {
+    subdomain,
+    method,
+    ...context,
+  };
+  const contextJson = JSON.stringify(contextData);
+  return Buffer.from(contextJson, 'utf8').toString('base64');
+}
+
+/**
+ * Decode the base64 JSON tRPC context header into tenant, method, and caller
+ * context. Returns null when the header is absent or malformed. Note: the
+ * header is an encoding, not an authentication credential.
+ */
+export function decodeTRPCContextHeader(headers: IncomingHttpHeaders): {
+  subdomain: string;
+  method: 'query' | 'mutation';
+  context: CommonTRPCContext;
+} | null {
+  const contextHeader = headers[trpcContextHeaderName];
+  if (!contextHeader) {
+    return null;
+  }
+  if (Array.isArray(contextHeader)) {
+    throw new Error(`Multiple ${trpcContextHeaderName} headers`);
+  }
+  try {
+    const contextJson = Buffer.from(contextHeader, 'base64').toString('utf-8');
+    const decoded = JSON.parse(contextJson);
+    const { subdomain, method, ...context } = decoded;
+    return { subdomain, method, context };
+  } catch (error) {
+    return null;
+  }
+}
+
+export const sendTRPCMessage = async ({
+  subdomain,
+  pluginName,
+  method,
+  module,
+  action,
+  input,
+  defaultValue,
+  options,
+  context,
+  throwOnError,
+}: MessageProps) => {
+  if (!method) {
+    method = 'query';
+  }
+
+  if (pluginName && !(await isEnabled(pluginName))) {
+    return defaultValue;
+  }
+
+  const pluginInfo = await getPlugin(pluginName);
+
+  const VERSION = getEnv({ name: 'VERSION' });
+
+  let client;
+
+  try {
+    // Encode context into header
+    const contextHeader = encodeTRPCContextHeader(subdomain, method, context);
+
+    if (VERSION && VERSION === 'saas') {
+      client = createTRPCUntypedClient({
+        links: [
+          httpBatchLink({
+            url: `https://${subdomain}.next.erxes.io/gateway/pl:${pluginName}/trpc`,
+            headers: () => ({
+              [trpcContextHeaderName]: contextHeader,
+            }),
+          }),
+        ],
+      });
+    } else {
+      // Validate plugin address before constructing URL
+      if (!pluginInfo.address || pluginInfo.address.trim() === '') {
+        if (throwOnError) {
+          throw new Error(`Plugin "${pluginName}" has no address`);
+        }
+
+        console.warn(
+          `Plugin "${pluginName}" address is not available. Returning defaultValue.`,
+        );
+        return defaultValue;
+      }
+
+      client = createTRPCUntypedClient({
+        links: [
+          httpBatchLink({
+            url: `${pluginInfo.address}/trpc`,
+            headers: () => ({
+              [trpcContextHeaderName]: contextHeader,
+            }),
+          }),
+        ],
+      });
+    }
+
+    const result = await client[method](`${module}.${action}`, input, options);
+    return result || defaultValue;
+  } catch (e) {
+    if (throwOnError) {
+      throw e;
+    }
+
+    return defaultValue;
+  }
+};
+
+/**
+ * Shared plugin-context initialization for in-process tRPC execution:
+ * request process state, event-handler runtime context, and scoped event
+ * handlers. Used by the /trpc express adapter and by the agent-tools
+ * endpoints so both paths build identical contexts.
+ */
+export const createPluginTRPCContext = async <TContext>(
+  subdomain: string,
+  reqContext: CommonTRPCContext,
+  trpcContext?: (subdomain: string, context: any) => Promise<TContext>,
+): Promise<TContext | TRPCContext> => {
+  const processInfo = generateRequestProcess();
+
+  const context: RequestTRPCContext = {
+    ...processInfo,
+    ...reqContext,
+    subdomain,
+  };
+
+  const runtimeContext = {
+    subdomain,
+    processId: context.processId || '',
+    userId: context.userId || '',
+  };
+
+  setEventHandlerRuntimeContext(subdomain, runtimeContext);
+
+  const eventHandlers = createScopedEventHandlers(subdomain, runtimeContext);
+
+  if (trpcContext) {
+    return await trpcContext(subdomain, {
+      ...context,
+      eventHandlers,
+    });
+  }
+
+  return {
+    ...context,
+    eventHandlers,
+  };
+};
+
+export const createTRPCContext =
+  <TContext>(
+    trpcContext: (
+      subdomain: string,
+      context: any,
+    ) => Promise<TContext & TRPCContext>,
+  ) =>
+  async ({
+    req,
+  }: trpcExpress.CreateExpressContextOptions): Promise<
+    TContext & TRPCContext
+  > => {
+    // Extract context from header (encoded) or fallback to request body/input
+    const decoded = decodeTRPCContextHeader(req.headers);
+    const subdomain = decoded?.subdomain;
+    const reqContext = decoded?.context;
+    const method = decoded?.method || 'query';
+
+    if (!subdomain || (method === 'mutation' && !reqContext)) {
+      throw new Error('Invalid context');
+    }
+
+    return (await createPluginTRPCContext(
+      subdomain,
+      reqContext || {},
+      trpcContext,
+    )) as TContext & TRPCContext;
+  };
+
+export type ITRPCContext<TExtraContext = object> = Awaited<
+  ReturnType<typeof createTRPCContext<TExtraContext>>
+>;
+
+export const ok = (data: any) => {
+  return {
+    status: 'success',
+    data,
+    timestamp: new Date().toISOString(),
+  };
+};
+
+export const err = (error: any) => {
+  return {
+    status: 'error',
+    error: {
+      code: error.code || 'SERVER_ERROR',
+      message: error.message || error.message,
+      details: error instanceof Error ? error.message : 'Database error',
+      ...(process.env.NODE_ENV === 'development' && {
+        stack: error instanceof Error ? error.stack : undefined,
+      }),
+      ...(error.suggestion && { suggestion: error.suggestion }),
+    },
+    timestamp: new Date().toISOString(),
+  };
+};

package/src/utils/trpc/sendCoreModuleProducer.ts

@@ -0,0 +1,146 @@
+import { getPlugin, isEnabled } from '../../utils/service-discovery';
+import {
+  createTRPCUntypedClient,
+  httpBatchLink,
+  TRPCRequestOptions,
+} from '@trpc/client';
+import { TAutomationProducers } from '../../core-modules/automations/types';
+import { TAutomationProducersInput } from '../../core-modules/automations/zodTypes';
+import { TSegmentProducers } from '../../core-modules/segments/types';
+import { TAfterProcessProducers } from '../../core-modules/logs/types';
+import {
+  TBeforeResolversProducers,
+  TBeforeResolversProducersInput,
+} from '../apollo/beforeResolvers';
+import { TSegmentProducersInput } from '../../core-modules/segments/zodSchemas';
+import { TImportExportProducersInput } from '../../core-modules/import-export/zodSchemas';
+import { TImportExportProducers } from '../../core-modules/import-export/types';
+import { encodeTRPCContextHeader, TRPCContext, trpcContextHeaderName } from '.';
+import {
+  TRecordReferenceProducers,
+  TRecordReferenceProducersInput,
+} from '../../core-modules/common/references/types';
+import {
+  TApprovalChangeProducers,
+  TApprovalChangeProducersInput,
+} from '../../core-modules/approval/types';
+import {
+  TPropertyProducers,
+  TPropertyProducersInput,
+} from '../../core-modules/properties/valueUsage';
+type TModuleProducerInputMap = {
+  automations: {
+    [K in TAutomationProducers]: TAutomationProducersInput[K];
+  };
+  segments: {
+    [K in TSegmentProducers]: TSegmentProducersInput[K];
+  };
+  afterProcess: {
+    [K in TAfterProcessProducers]: any;
+  };
+  beforeResolvers: {
+    [K in TBeforeResolversProducers]: TBeforeResolversProducersInput[K];
+  };
+  importExport: {
+    [K in TImportExportProducers]: TImportExportProducersInput[K];
+  };
+  references: {
+    [K in TRecordReferenceProducers]: TRecordReferenceProducersInput[K];
+  };
+  approval: {
+    [K in TApprovalChangeProducers]: TApprovalChangeProducersInput[K];
+  };
+  properties: {
+    [K in TPropertyProducers]: TPropertyProducersInput[K];
+  };
+};
+
+type TCoreModuleProducer<
+  TModuleName extends keyof TModuleProducerInputMap =
+    keyof TModuleProducerInputMap,
+  TProducerName extends keyof TModuleProducerInputMap[TModuleName] =
+    keyof TModuleProducerInputMap[TModuleName],
+> = {
+  subdomain: string;
+  moduleName: TModuleName;
+  producerName: TProducerName;
+  method?: 'query' | 'mutation';
+  pluginName: string;
+  input: TModuleProducerInputMap[TModuleName][TProducerName];
+  defaultValue?: any;
+  options?: TRPCRequestOptions;
+  context?: TRPCContext;
+};
+
+export const sendCoreModuleProducer = async <
+  TModuleName extends keyof TModuleProducerInputMap =
+    keyof TModuleProducerInputMap,
+  TProducerName extends keyof TModuleProducerInputMap[TModuleName] =
+    keyof TModuleProducerInputMap[TModuleName],
+>({
+  subdomain,
+  moduleName,
+  pluginName,
+  method = 'mutation',
+  producerName,
+  input,
+  defaultValue,
+  options,
+  context,
+}: TCoreModuleProducer<TModuleName, TProducerName>): Promise<any> => {
+  if (pluginName && !(await isEnabled(pluginName))) {
+    return defaultValue;
+  }
+
+  const pluginInfo = await getPlugin(pluginName);
+
+  // Validate plugin address before constructing URL
+  if (!pluginInfo.address || pluginInfo.address.trim() === '') {
+    console.warn(
+      `Plugin "${pluginName}" address is not available. Returning defaultValue.`,
+    );
+    return defaultValue;
+  }
+  const contextHeader = encodeTRPCContextHeader(subdomain, method, context);
+
+  const baseUrl = `${pluginInfo.address}/${moduleName}`;
+
+  try {
+    const client = createTRPCUntypedClient({
+      links: [
+        httpBatchLink({
+          url: baseUrl,
+          headers: () => ({
+            [trpcContextHeaderName]: contextHeader,
+          }),
+        }),
+      ],
+    });
+
+    const result = await client[method](
+      String(producerName),
+      { subdomain, data: input ?? {} },
+      options,
+    );
+
+    return result || defaultValue;
+  } catch (error: any) {
+    const errorMessage = error?.message || 'Unknown error';
+    const errorCode = error?.cause?.code || error?.code;
+
+    if (errorCode === 'ECONNREFUSED') {
+      console.warn(
+        `[TRPC] Connection refused to plugin "${pluginName}" at ${baseUrl}. ` +
+          `The plugin service may not be running or is not accessible. ` +
+          `Returning defaultValue.`,
+      );
+    } else {
+      console.warn(
+        `[TRPC] Error calling plugin "${pluginName}" at ${baseUrl}: ${errorMessage}. ` +
+          `Returning defaultValue.`,
+      );
+    }
+
+    throw error;
+  }
+};

package/src/utils/trpc/trpc-setup.ts

@@ -0,0 +1,91 @@
+import { Application } from 'express';
+import * as trpcExpress from '@trpc/server/adapters/express';
+// import rateLimit from 'express-rate-limit';
+import helmet from 'helmet';
+import { createTRPCContext, TRPCContext } from '../../utils';
+// import {
+//   createTRPCSecurityMiddleware,
+//   createTRPCSecurityLoggingMiddleware,
+//   defaultTRPCSecurityConfig,
+//   TRPCSecurityConfig,
+// } from './trpc-middleware';
+
+export interface TRPCSetupOptions {
+  router: any;
+  createContext: <TContext>(
+    subdomain: string,
+    context: any,
+  ) => Promise<TContext & TRPCContext>;
+  // securityConfig?: TRPCSecurityConfig;
+  rateLimitConfig?: {
+    windowMs?: number;
+    max?: number;
+  };
+  helmetConfig?: Record<string, any>;
+}
+
+export function setupTRPCRoute(app: Application, options: TRPCSetupOptions) {
+  const {
+    router,
+    createContext,
+    // securityConfig = defaultTRPCSecurityConfig,
+    rateLimitConfig = {
+      windowMs: 15 * 60 * 1000, // 15 minutes
+      max: 100, // 100 requests per window
+    },
+    helmetConfig = {
+      contentSecurityPolicy: {
+        directives: {
+          defaultSrc: ["'self'"],
+          scriptSrc: ["'self'"],
+          styleSrc: ["'self'", "'unsafe-inline'"],
+          imgSrc: ["'self'", 'data:', 'https:'],
+        },
+      },
+      crossOriginEmbedderPolicy: false,
+    },
+  } = options;
+
+  // app.use(createTRPCSecurityLoggingMiddleware());
+
+  // // // Raw body parsing middleware for signature verification
+  // app.use('/trpc', (req, res, next) => {
+  //   if (req.method === 'POST') {
+  //     let data = '';
+  //     req.setEncoding('utf8');
+  //     req.on('data', (chunk) => {
+  //       data += chunk;
+  //     });
+  //     req.on('end', () => {
+  //       (req as any).rawBody = data;
+  //       next();
+  //     });
+  //   } else {
+  //     next();
+  //   }
+  // });
+
+  // const trpcRateLimit = rateLimit({
+  //   windowMs: rateLimitConfig.windowMs,
+  //   max: rateLimitConfig.max,
+  //   message: {
+  //     error: 'Too Many Requests',
+  //     message: 'Rate limit exceeded. Please try again later.',
+  //   },
+  //   standardHeaders: true,
+  //   legacyHeaders: false,
+  // });
+
+  const trpcHelmet = helmet(helmetConfig);
+
+  app.use(
+    '/trpc',
+    trpcHelmet,
+    // trpcRateLimit,
+    // createTRPCSecurityMiddleware(securityConfig),
+    trpcExpress.createExpressMiddleware({
+      router,
+      createContext: createTRPCContext(createContext),
+    }),
+  );
+}