@app-connect/core 1.7.37 → 1.7.38

package/dist/types/manifest.d.ts

@@ -0,0 +1,120 @@
+import type { JsonObject, JsonValue } from './json';
+
+export type ConnectorAuthType = 'oauth' | 'apiKey' | (string & {});
+
+export interface AuthorInfo {
+  name?: string;
+  websiteUrl?: string;
+  [key: string]: JsonValue | undefined;
+}
+
+export interface EnvironmentSelection {
+  const: string;
+  name: string;
+  [key: string]: JsonValue;
+}
+
+export interface ConnectorEnvironment {
+  type: 'fixed' | 'dynamic' | 'selectable' | (string & {});
+  url?: string;
+  urlIdentifier?: string;
+  instructions?: string[];
+  selections?: EnvironmentSelection[];
+  [key: string]: JsonValue | undefined;
+}
+
+export interface PageField {
+  const: string;
+  title?: string;
+  type?: string;
+  required?: boolean;
+  default?: JsonValue;
+  [key: string]: JsonValue | undefined;
+}
+
+export interface OAuthManifestConfig {
+  authUrl?: string;
+  clientId?: string;
+  redirectUri?: string;
+  scope?: string;
+  customState?: string;
+  [key: string]: JsonValue | undefined;
+}
+
+export interface ApiKeyManifestConfig {
+  page?: {
+    title?: string;
+    content?: PageField[];
+    [key: string]: JsonValue | undefined;
+  };
+  [key: string]: JsonValue | undefined;
+}
+
+export interface ManifestAuthConfig {
+  type: ConnectorAuthType;
+  oauth?: OAuthManifestConfig;
+  apiKey?: ApiKeyManifestConfig;
+  [key: string]: JsonValue | undefined;
+}
+
+export interface ServerSideLoggingConfig {
+  url?: string;
+  useAdminAssignedUserToken?: boolean;
+  enableUserMapping?: boolean;
+  additionalFields?: PageField[];
+  [key: string]: JsonValue | undefined;
+}
+
+export interface ContactTypeConfig {
+  id?: string;
+  name?: string;
+  type?: string;
+  [key: string]: JsonValue | undefined;
+}
+
+export interface PlatformPageConfig {
+  useContactSearch?: boolean;
+  disableContactCache?: boolean;
+  callLog?: JsonObject;
+  messageLog?: JsonObject;
+  [key: string]: JsonValue | undefined;
+}
+
+export interface PlatformManifest {
+  name: string;
+  displayName?: string;
+  developer?: AuthorInfo;
+  environment?: ConnectorEnvironment;
+  urlIdentifier?: string;
+  embedUrls?: string[];
+  logoUrl?: string;
+  documentationUrl?: string;
+  releaseNotesUrl?: string;
+  getSupportUrl?: string;
+  writeReviewUrl?: string;
+  auth: ManifestAuthConfig;
+  serverSideLogging?: ServerSideLoggingConfig;
+  contactTypes?: ContactTypeConfig[];
+  contactPageUrl?: string;
+  enableFallbackContactPageUrl?: boolean;
+  fallbackContactPageUrl?: string;
+  logPageUrl?: string;
+  canOpenLogPage?: boolean;
+  settings?: JsonValue[];
+  page?: PlatformPageConfig;
+  requestConfig?: JsonObject;
+  enableExtensionNumberLoggingSetting?: boolean;
+  trackSmsTypingDuration?: boolean;
+  rcAdditionalSubmission?: string[];
+  override?: JsonObject;
+  [key: string]: JsonValue | undefined;
+}
+
+export interface AppConnectManifest {
+  serverUrl?: string;
+  redirectUri?: string;
+  author?: AuthorInfo;
+  platforms: Record<string, PlatformManifest>;
+  version?: string;
+  [key: string]: JsonValue | undefined;
+}

package/dist/types/migration.d.ts

@@ -0,0 +1,15 @@
+export type SequelizeLike = any;
+
+export type SequelizeTransactionLike = any;
+
+export type TableDescription = Record<string, unknown>;
+
+export interface PostgresClientLike {
+  query(sql: string, params?: unknown[]): Promise<{ rows: any[] }>;
+}
+
+export interface MigrationLogger {
+  info?(message: string, context?: Record<string, unknown>): void;
+  warn?(message: string, context?: Record<string, unknown>): void;
+  error?(message: string, context?: Record<string, unknown>): void;
+}

package/dist/types/plugin.d.ts

@@ -0,0 +1,74 @@
+import type { JsonObject } from './json';
+import type { PlatformManifest } from './manifest';
+
+export type PluginAccess = 'public' | 'private' | 'shared' | (string & {});
+
+export type PluginLogType = 'call' | 'sms' | 'fax' | (string & {});
+
+export interface PluginManifest extends PlatformManifest {
+  endpointUrl: string;
+  supportedLogTypes: PluginLogType[];
+  isAsync?: boolean;
+  tokenSyncUrl?: string;
+  userRegisterEndpointUrl?: string;
+  licenseStatusUrl?: string;
+  jwtToken?: string;
+  phase?: string;
+  access?: PluginAccess;
+}
+
+export interface InstalledPlugin {
+  id: string;
+  data: PluginManifest;
+}
+
+export interface AsyncPluginTaskData {
+  type: 'asyncPluginTask';
+  asyncTaskId: string;
+  callbackUrl: string;
+  pluginId: string;
+  platform: string;
+  logType: PluginLogType;
+  operation: string;
+  userId: string | number;
+  rcAccountId?: string | number;
+  sessionId?: string;
+  extensionNumber?: string;
+  hashedExtensionId?: string;
+  callLogId?: string | number;
+  thirdPartyLogId?: string | number;
+  contactId?: string | number;
+  incomingData: unknown;
+  hashedAccountId?: string;
+  isFromSSCL?: boolean;
+  [key: string]: unknown;
+}
+
+export interface PluginInvocationBody {
+  data: unknown;
+  config?: JsonObject | null;
+  asyncTaskId?: string;
+  callbackUrl?: string;
+  hashedExtensionId?: string;
+}
+
+export interface PluginLicenseStatus {
+  licenseStatus: boolean;
+  licenseStatusDescription?: string;
+  [key: string]: unknown;
+}
+
+export interface ResolvePluginManifestResult {
+  pluginData: {
+    platforms?: Record<string, PluginManifest>;
+    [key: string]: unknown;
+  };
+  pluginManifest: PluginManifest;
+  platformKey: string;
+}
+
+export interface RegisterPluginAccountResult {
+  successful: true;
+  registerUrl: string;
+  jwtToken: string;
+}

package/dist/types/ringcentral.d.ts

@@ -0,0 +1,61 @@
+export interface RingCentralOptions {
+  server: string;
+  clientId: string;
+  clientSecret: string;
+  redirectUri: string;
+}
+
+export interface RingCentralToken {
+  access_token?: string;
+  refresh_token?: string;
+  token_type?: string;
+  expires_in?: string | number;
+  refresh_token_expires_in?: string | number;
+  expire_time?: number;
+  refresh_token_expire_time?: number;
+  [key: string]: unknown;
+}
+
+export interface RingCentralLoginUrlParams {
+  state?: string;
+}
+
+export interface RingCentralGenerateTokenParams {
+  code: string;
+}
+
+export interface RingCentralRequestOptions {
+  server?: string;
+  path: string;
+  query?: Record<string, any>;
+  body?: unknown;
+  method: string;
+  accept?: string;
+}
+
+export interface RingCentralFetchResponse {
+  status: string | number;
+  json(): Promise<any>;
+  text(): Promise<string>;
+  [key: string]: unknown;
+}
+
+export interface RingCentralSubscriptionParams {
+  eventFilters: string[];
+  webhookUri: string;
+}
+
+export interface RingCentralCallsAggregationParams {
+  token: RingCentralToken;
+  timezone: string;
+  timeFrom: string;
+  timeTo: string;
+  groupBy: string;
+}
+
+export interface RingCentralPaginatedDataParams {
+  extensionId?: string | number;
+  token: RingCentralToken;
+  timeFrom: string;
+  timeTo: string;
+}

package/dist/types/s3ErrorLogReport.d.ts

@@ -0,0 +1,16 @@
+export interface S3ErrorLogMetadata {
+  [key: string]: string | number | boolean | undefined;
+}
+
+export interface UploadUrlParams {
+  userId: string;
+  platform: string;
+  metadata?: S3ErrorLogMetadata;
+}
+
+export interface AwsSdkErrorLike extends Error {
+  $metadata?: {
+    httpStatusCode?: number;
+    [key: string]: unknown;
+  };
+}

package/dist/types/sharedSMSComposer.d.ts

@@ -0,0 +1,105 @@
+export type SharedSMSLogFormat = 'text/plain' | 'text/html' | 'text/markdown' | (string & {});
+
+export interface SharedSMSNamedParty {
+  name?: string;
+  [key: string]: unknown;
+}
+
+export interface SharedSMSEntity {
+  recordType?: string;
+  creationTime?: any;
+  direction?: string;
+  author?: SharedSMSNamedParty;
+  from?: SharedSMSNamedParty | null;
+  initiator?: SharedSMSNamedParty;
+  assignee?: SharedSMSNamedParty;
+  text?: string;
+  subject?: string;
+  body?: string;
+  [key: string]: unknown;
+}
+
+export interface SharedSMSMessage {
+  lastModifiedTime?: any;
+  [key: string]: unknown;
+}
+
+export interface SharedSMSOwner {
+  name?: string;
+  extensionType?: string;
+  extensionId?: string | number;
+  [key: string]: unknown;
+}
+
+export interface SharedSMSConversation {
+  creationTime?: any;
+  messages: SharedSMSMessage[];
+  entities?: SharedSMSEntity[];
+  owner?: SharedSMSOwner;
+  [key: string]: unknown;
+}
+
+export interface ComposeSharedSMSLogParams {
+  logFormat?: SharedSMSLogFormat;
+  conversation: SharedSMSConversation;
+  contactName: string;
+  timezoneOffset?: string | number;
+}
+
+export interface SharedSMSLogContent {
+  subject: string;
+  body: string;
+}
+
+export interface SharedSMSOwnerInfo {
+  type: 'callQueue' | 'user';
+  name: string;
+  extensionId?: string | number;
+}
+
+export interface SharedSMSEntityCounts {
+  messageCount: number;
+  noteCount: number;
+}
+
+export interface SharedSMSProcessedEntry {
+  type: string;
+  creationTime: any;
+  content: string;
+}
+
+export interface ComposeSharedSMSBodyParams extends ComposeSharedSMSLogParams {
+  conversationCreatedDate: any;
+  conversationUpdatedDate: any;
+  logFormat: SharedSMSLogFormat;
+}
+
+export interface ProcessSharedSMSEntitiesParams {
+  entities: SharedSMSEntity[];
+  timezoneOffset?: string | number;
+  logFormat: SharedSMSLogFormat;
+  contactName: string;
+}
+
+export interface ProcessSharedSMSEntityParams extends Omit<ProcessSharedSMSEntitiesParams, 'entities'> {
+  entity: SharedSMSEntity;
+}
+
+export interface FormatSharedSMSEntryParams {
+  entity: SharedSMSEntity;
+  formattedTime: string;
+  creationTime: any;
+  logFormat: SharedSMSLogFormat;
+  contactName?: string;
+}
+
+export interface ComposeSharedSMSFormattedBodyParams {
+  conversationCreatedDate: any;
+  conversationUpdatedDate: any;
+  contactName: string;
+  agents: string[];
+  ownerInfo: SharedSMSOwnerInfo | null;
+  messageCount: number;
+  noteCount: number;
+  formattedEntries: SharedSMSProcessedEntry[];
+}

package/dist/types/user.d.ts

@@ -0,0 +1,46 @@
+import type { ReturnMessage, UserSettings } from './common';
+
+export interface TraceLogger {
+  trace(event: string, data?: unknown): void;
+  traceError(event: string, error: unknown, data?: unknown): void;
+}
+
+export interface RefreshUserInfoParams {
+  platform: string;
+  userId: string | number;
+  tracer?: TraceLogger;
+}
+
+export interface HandlerResult {
+  successful?: boolean;
+  returnMessage?: ReturnMessage;
+  isRevokeUserSession?: boolean;
+  [key: string]: unknown;
+}
+
+export interface UserSettingsByAdminParams {
+  rcAccessToken?: string;
+  rcAccountId?: string | number | null;
+}
+
+export interface UserSettingsByAdminResult {
+  userSettings?: UserSettings;
+}
+
+export interface GetUserSettingsParams extends UserSettingsByAdminParams {
+  user?: {
+    userSettings?: UserSettings;
+    [key: string]: unknown;
+  } | null;
+}
+
+export interface UpdateUserSettingsParams {
+  user: {
+    userSettings?: UserSettings;
+    update(values: { userSettings: UserSettings }): Promise<unknown>;
+    [key: string]: unknown;
+  };
+  userSettings?: UserSettings;
+  settingKeysToRemove: string[];
+  platformName: string;
+}

package/dist/types/util.d.ts

@@ -0,0 +1,7 @@
+export interface MostRecentDateParams {
+  allDateValues: Array<number | null | undefined>;
+}
+
+export type SecondsInput = any;
+
+export type MediaLinkInput = string | null | undefined;

package/package.json

@@ -1,8 +1,28 @@
 {
   "name": "@app-connect/core",
-  "version": "1.7.37",
+  "version": "1.7.38",
   "description": "RingCentral App Connect Core",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./types": {
+      "types": "./dist/types/index.d.ts"
+    },
+    "./types/*": {
+      "types": "./dist/types/*.d.ts"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "require": "./dist/*.js",
+      "default": "./dist/*.js"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ringcentral/rc-unified-crm-extension.git"
@@ -11,6 +31,11 @@
     "RingCentral",
     "App Connect"
   ],
+  "files": [
+    "dist",
+    "README.md",
+    "releaseNotes.json"
+  ],
   "author": "RingCentral Labs",
   "license": "MIT",
   "peerDependencies": {
@@ -26,6 +51,7 @@
     "@aws-sdk/client-s3": "^3.947.0",
     "@aws-sdk/s3-request-presigner": "^3.947.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "@types/express": "^4.17.25",
     "awesome-phonenumber": "^5.6.0",
     "body-parser": "^1.20.4",
     "body-parser-xml": "^2.0.5",
@@ -41,10 +67,12 @@
     "ua-parser-js": "^1.0.38"
   },
   "scripts": {
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:ci": "jest --ci --coverage --watchAll=false"
+    "test": "cd ../.. && npm run build:ts && cd packages/core && npm run test:raw",
+    "test:raw": "jest --config ../../.ts-build/packages/core/jest.config.js",
+    "test:watch": "cd ../.. && npm run build:ts && cd packages/core && jest --config ../../.ts-build/packages/core/jest.config.js --watch",
+    "test:coverage": "cd ../.. && npm run build:ts && cd packages/core && jest --config ../../.ts-build/packages/core/jest.config.js --coverage",
+    "test:ci": "cd ../.. && npm run build:ts && cd packages/core && jest --config ../../.ts-build/packages/core/jest.config.js --ci --coverage --watchAll=false",
+    "prepack": "cd ../.. && npm run build:ts"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",

package/releaseNotes.json

@@ -1,4 +1,12 @@
 {
+    "1.7.38": {
+        "global": [
+            {
+                "type": "Fix",
+                "description": "Security patches"
+            }
+        ]
+    },
     "1.7.37": {
         "global": [
             {

package/.env.test

@@ -1,5 +0,0 @@
-NODE_ENV=test
-APP_SERVER_SECRET_KEY='test-secret-key'
-HASH_KEY='test-hash-key'
-DISABLE_SYNC_DB_TABLE='true'
-DATABASE_URL='sqlite::memory:'

package/connector/proxy/engine.js

@@ -1,165 +0,0 @@
-const axios = require('axios');
-
-function getByPath(obj, path) {
-  if (!path || path === '$') return obj;
-  const parts = path.split('.');
-  let cur = obj;
-  for (const p of parts) {
-    if (cur == null) return undefined;
-    cur = cur[p];
-  }
-  return cur;
-}
-
-function renderTemplateString(template, context) {
-  if (typeof template !== 'string') return template;
-  // if only template value, return value with stringify
-  const onlyVarName = template.match(/^\{\{\s*([^}]+?)\s*\}\}$/);
-  if (onlyVarName) {
-    return getByPath(context, onlyVarName[1]);
-  }
-  return template.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_, expr) => {
-    const value = getByPath(context, expr.trim());
-    return value == null ? '' : String(value);
-  });
-}
-
-function renderDeep(input, context) {
-  if (input == null) return input;
-  if (typeof input === 'string') return renderTemplateString(input, context);
-  if (Array.isArray(input)) return input.map(v => renderDeep(v, context));
-  if (typeof input === 'object') {
-    const out = {};
-    for (const [k, v] of Object.entries(input)) {
-      out[k] = renderDeep(v, context);
-    }
-    return out;
-  }
-  return input;
-}
-
-function joinUrl(baseUrl, path) {
-  if (!baseUrl) return path;
-  if (!path) return baseUrl;
-  if (path.startsWith('http://') || path.startsWith('https://')) return path;
-  return `${baseUrl.replace(/\/$/, '')}/${path.replace(/^\//, '')}`;
-}
-
-function getAuthHeaderFromAuthConfig({ auth, context, authHeader }) {
-  const authHeaders = {};
-  const headerName = auth?.headerName || 'Authorization';
-  if (auth && auth.credentialTemplate) {
-    const credentials = renderTemplateString(auth.credentialTemplate, context);
-    const encode = auth.encode === 'none' ? false : true;
-    const token = encode ? Buffer.from(credentials).toString('base64') : credentials;
-    authHeaders[headerName] = auth.scheme ? `${auth.scheme} ${token}` : token;
-  } else if (authHeader) {
-    authHeaders[headerName] = authHeader;
-  } else if (auth && auth.type === 'oauth' && context.user) {
-    authHeaders[headerName] = `${auth.scheme || 'Bearer'} ${context.user.accessToken}`;
-  }
-  return authHeaders;
-}
-
-function buildHeaders({ config, operation, authHeader, context }) {
-  const headers = renderDeep(Object.assign({}, config.requestDefaults?.defaultHeaders || {}), context);
-  const renderedOpHeaders = renderDeep(operation?.headers || {}, context);
-  for (const [k, v] of Object.entries(renderedOpHeaders)) headers[k] = v;
-
-  // Per-operation auth override
-  const authHeaders = getAuthHeaderFromAuthConfig({
-    auth: operation?.auth || config.auth,
-    context,
-    authHeader
-  });
-  for (const [k, v] of Object.entries(authHeaders)) headers[k] = v;
-  return headers;
-}
-
-async function performRequest({ config, opName, inputs, user, authHeader }) {
-  const op = config.operations?.[opName];
-  if (!op) return null;
-  const accessToken = user?.accessToken ?? inputs?.apiKey ?? '';
-  const context = Object.assign({}, inputs, {
-    user: user ? {
-      accessToken,
-      id: user.id?.split('-')[0],
-      hostname: user.hostname,
-      timezoneName: user.timezoneName,
-      timezoneOffset: user.timezoneOffset,
-      platform: user.platform,
-      platformAdditionalInfo: user.platformAdditionalInfo,
-      refreshToken: user.refreshToken,
-      tokenExpiry: user.tokenExpiry,
-    } : {
-      accessToken,
-    },
-    authHeader,
-    apiKey: accessToken,
-    secretKey: config.secretKey,
-  });
-  const url = joinUrl(config.requestDefaults?.baseUrl, renderTemplateString(op.url, context));
-  const method = (op.method || 'GET').toUpperCase();
-  const headers = buildHeaders({ config, operation: op, authHeader, context });
-  const params = renderDeep(op.query || {}, context);
-  const data = renderDeep(op.body || {}, context);
-  const timeout = (config.requestDefaults?.timeoutSeconds || 30) * 1000;
-  const axiosParams = { url, method, headers, params, data, timeout };
-  const response = await axios(axiosParams);
-  return response;
-}
-
-function mapFindContactResponse({ config, response, opName = 'findContact' }) {
-  const map = config.operations?.[opName]?.responseMapping;
-  if (!map) return [];
-  const __ctx = { body: response.data };
-  const list = getByPath(__ctx, map.listPath || 'body') || [];
-  const itemMap = map.item || {};
-  return list.map(it => {
-    return {
-      id: getByPath(it, itemMap.idPath || 'id'),
-      name: getByPath(it, itemMap.namePath || 'name') || '',
-      phone: getByPath(it, itemMap.phonePath || 'phone') || undefined,
-      type: getByPath(it, itemMap.typePath || 'type') || 'Contact',
-      title: getByPath(it, itemMap.titlePath || 'title') || "",
-      company: getByPath(it, itemMap.companyPath || 'company') || "",
-      createdDate: getByPath(it, itemMap.createdDatePath || 'createdDate') || undefined,
-      mostRecentActivityDate: getByPath(it, itemMap.mostRecentActivityDatePath || 'mostRecentActivityDate') || undefined,
-      additionalInfo: getByPath(it, itemMap.additionalInfoPath || 'additionalInfo') || null
-    };
-  });
-}
-
-function mapCreateCallLogResponse({ config, response }) {
-  const map = config.operations?.createCallLog?.responseMapping;
-  if (!map) return { logId: undefined };
-  const __ctx = { body: response.data };
-  const logId = getByPath(__ctx, map.idPath || 'body.id');
-
-  return { logId: logId ? String(logId) : undefined };
-}
-
-function mapGetCallLogResponse({ config, response }) {
-  const map = config.operations?.getCallLog?.responseMapping || {};
-  const __ctx = { body: response.data };
-  const subject = getByPath(__ctx, map.subjectPath || 'body.subject');
-  const note = getByPath(__ctx, map.notePath || 'body.note');
-  const fullBody = getByPath(__ctx, map.fullBodyPath || 'body.note');
-  const fullLogResponse = response.data;
-  return {
-    callLogInfo: { subject, note, fullBody, fullLogResponse }
-  };
-}
-
-module.exports = {
-  getByPath,
-  renderTemplateString,
-  renderDeep,
-  joinUrl,
-  performRequest,
-  mapFindContactResponse,
-  mapCreateCallLogResponse,
-  mapGetCallLogResponse
-};
-
-