@app-connect/core 1.7.36 → 1.7.38

package/README.md

@@ -376,7 +376,8 @@ The core package provides the following API endpoints:
 
 The core package uses the following environment variables:
 
-- `DATABASE_URL` - Database connection string for Sequelize ORM
+- `DATABASE_URL` - Database connection string for Sequelize ORM. SQLite and Postgres URLs are supported.
+- `DATABASE_SSL` - Optional Postgres SSL override. When unset, localhost database hosts use SSL off and other Postgres hosts use SSL on.
 - `DISABLE_SYNC_DB_TABLE` - Skip database table synchronization
 - `OVERRIDE_APP_SERVER` - Override app server URL in manifests
 - `HASH_KEY` - Key for hashing user information
@@ -415,24 +416,24 @@ The core package uses the following environment variables:
 ```
 Core Package
 ├── Handlers (Business Logic)
-│   ├── auth.js      - Authentication logic
-│   ├── contact.js   - Contact management
-│   ├── log.js       - Call/message logging
-│   ├── admin.js     - Admin operations
-│   ├── user.js      - User management
-│   └── disposition.js - Call disposition
+│   ├── auth.ts      - Authentication logic
+│   ├── contact.ts   - Contact management
+│   ├── log.ts       - Call/message logging
+│   ├── admin.ts     - Admin operations
+│   ├── user.ts      - User management
+│   └── disposition.ts - Call disposition
 ├── Models (Data Layer)
-│   ├── userModel.js
-│   ├── callLogModel.js
-│   ├── messageLogModel.js
-│   ├── adminConfigModel.js
-│   └── cacheModel.js
+│   ├── userModel.ts
+│   ├── callLogModel.ts
+│   ├── messageLogModel.ts
+│   ├── adminConfigModel.ts
+│   └── cacheModel.ts
 ├── Utils (Utilities)
-│   ├── jwt.js       - JWT operations
-│   ├── analytics.js - Analytics tracking
-│   └── util.js      - General utilities
+│   ├── jwt.ts       - JWT operations
+│   ├── analytics.ts - Analytics tracking
+│   └── util.ts      - General utilities
 ├── Connector Registry
-│   └── registry.js  - CRM connector management
+│   └── registry.ts  - CRM connector management
 └── API Layer
     ├── createCoreApp()     - Complete app setup
     ├── createCoreRouter()  - Route management

package/dist/connector/developerPortal.d.ts

@@ -0,0 +1,6 @@
+/** @typedef {import('../types').ConnectorManifest} ConnectorManifest */
+/** @typedef {import('../types').DeveloperPortalConnectorList} DeveloperPortalConnectorList */
+/** @typedef {import('../types').DeveloperPortalPrivateConnectorList} DeveloperPortalPrivateConnectorList */
+/** @typedef {import('../types').GetConnectorManifestParams} GetConnectorManifestParams */
+/** @typedef {import('../types').GetPrivateConnectorListParams} GetPrivateConnectorListParams */
+export {};

package/{connector → dist/connector}/developerPortal.js

@@ -1,32 +1,49 @@
-const axios = require('axios');
-const { logger } = require('../lib/logger');
-
-
+"use strict";
+// @ts-check
+/** @typedef {import('../types').ConnectorManifest} ConnectorManifest */
+/** @typedef {import('../types').DeveloperPortalConnectorList} DeveloperPortalConnectorList */
+/** @typedef {import('../types').DeveloperPortalPrivateConnectorList} DeveloperPortalPrivateConnectorList */
+/** @typedef {import('../types').GetConnectorManifestParams} GetConnectorManifestParams */
+/** @typedef {import('../types').GetPrivateConnectorListParams} GetPrivateConnectorListParams */
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios = /** @type {any} */ (require('axios'));
+const logger = require('../lib/logger');
+/**
+ * @returns {Promise<DeveloperPortalConnectorList | null>}
+ */
 async function getPublicConnectorList() {
     try {
         const response = await axios.get('https://appconnect.labs.ringcentral.com/public-api/connectors');
         return response.data;
-    } catch (error) {
+    }
+    catch (error) {
         logger.error('Error getting public connector list:', error);
         return null;
     }
 }
-
+/**
+ * @param {GetPrivateConnectorListParams} params
+ * @returns {Promise<DeveloperPortalPrivateConnectorList | null>}
+ */
 async function getPrivateConnectorList({ rcAccountId }) {
     try {
         const response = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/internal?accountId=${rcAccountId}`);
         return response.data;
-    } catch (error) {
+    }
+    catch (error) {
         logger.error('Error getting private connector list:', error);
         return null;
     }
 }
-
+/**
+ * @param {GetConnectorManifestParams} params
+ * @returns {Promise<ConnectorManifest | null>}
+ */
 async function getConnectorManifest({ rcAccountId, connectorId, isPrivate = false }) {
     try {
         let response = null;
         if (isPrivate) {
-            const privateConnectorList = await getPrivateConnectorList({ rcAccountId });
+            const privateConnectorList = /** @type {DeveloperPortalPrivateConnectorList} */ (await getPrivateConnectorList({ rcAccountId }));
             if (privateConnectorList.privateConnectors.some(connector => connector.id === connectorId)) {
                 response = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${connectorId}/manifest?access=internal&type=connector&accountId=${rcAccountId}`);
             }
@@ -42,11 +59,11 @@ async function getConnectorManifest({ rcAccountId, connectorId, isPrivate = fals
             response = await axios.get(`https://appconnect.labs.ringcentral.com/public-api/connectors/${connectorId}/manifest`);
         }
         return response.data;
-    } catch (error) {
+    }
+    catch (error) {
         logger.error('Error getting connector manifest:', error);
         return null;
     }
 }
-
 exports.getPublicConnectorList = getPublicConnectorList;
-exports.getConnectorManifest = getConnectorManifest;
+exports.getConnectorManifest = getConnectorManifest;

package/dist/connector/mock.d.ts

@@ -0,0 +1 @@
+export {};

package/{connector → dist/connector}/mock.js

@@ -1,13 +1,20 @@
+"use strict";
 // This mock is to run high traffic tests on the server
-
-const { UserModel } = require("../models/userModel");
-const { CallLogModel } = require("../models/callLogModel");
-const shortid = require("shortid");
-const {
-    buildCallLogSessionWhere,
-    findMatchingCallLog,
-} = require('../lib/callLogLookup');
-
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-check
+const { UserModel: UserModelImport } = require("../models/userModel");
+const { CallLogModel: CallLogModelImport } = require("../models/callLogModel");
+const shortid = /** @type {any} */ (require("shortid"));
+const { buildCallLogSessionWhere, findMatchingCallLog, } = require('../lib/callLogLookup');
+const UserModel = /** @type {any} */ (UserModelImport);
+const CallLogModel = /** @type {any} */ (CallLogModelImport);
+/** @typedef {import('../types').MockCallLogMatchResult} MockCallLogMatchResult */
+/** @typedef {import('../types').MockCreateCallLogParams} MockCreateCallLogParams */
+/** @typedef {import('../types').MockGetCallLogParams} MockGetCallLogParams */
+/** @typedef {import('../types').PersistedCallLogIdentity} PersistedCallLogIdentity */
+/**
+ * @returns {Promise<unknown>}
+ */
 async function createUser() {
     let mockUser = await UserModel.findByPk('mockUser');
     if (!mockUser) {
@@ -17,7 +24,9 @@ async function createUser() {
     }
     return mockUser;
 }
-
+/**
+ * @returns {Promise<boolean>}
+ */
 async function deleteUser() {
     let mockUser = await UserModel.findByPk('mockUser');
     if (mockUser) {
@@ -26,19 +35,23 @@ async function deleteUser() {
     }
     return false;
 }
-
+/**
+ * @param {MockGetCallLogParams} params
+ * @returns {Promise<MockCallLogMatchResult[]>}
+ */
 async function getCallLog({ sessionIds, extensionNumber, hashedExtensionId }) {
     const sessionIdsArray = sessionIds.split(',');
     const extensionNumberValue = extensionNumber?.toString() ?? '';
     const hashedExtensionIdValue = hashedExtensionId?.toString() ?? '';
-    const callLogs = await CallLogModel.findAll({
+    const callLogs = /** @type {PersistedCallLogIdentity[]} */ (await CallLogModel.findAll({
         where: buildCallLogSessionWhere({
             sessionIds: sessionIdsArray,
             extensionNumber: extensionNumberValue,
             hashedExtensionId: hashedExtensionIdValue,
         }),
         order: [['hashedExtensionId', 'ASC'], ['extensionNumber', 'ASC']]
-    });
+    }));
+    /** @type {MockCallLogMatchResult[]} */
     const logs = [];
     for (const sId of sessionIdsArray) {
         const callLog = findMatchingCallLog(callLogs, sId, extensionNumberValue, hashedExtensionIdValue);
@@ -49,10 +62,12 @@ async function getCallLog({ sessionIds, extensionNumber, hashedExtensionId }) {
             logs.push({ sessionId: callLog.sessionId, matched: true, logId: 'mockThirdPartyLogId' });
         }
     }
-
     return logs;
 }
-
+/**
+ * @param {MockCreateCallLogParams} params
+ * @returns {Promise<void>}
+ */
 async function createCallLog({ sessionId, extensionNumber, hashedExtensionId }) {
     const extensionNumberValue = extensionNumber?.toString() ?? '';
     const hashedExtensionIdValue = hashedExtensionId?.toString() ?? '';
@@ -73,7 +88,9 @@ async function createCallLog({ sessionId, extensionNumber, hashedExtensionId })
         });
     }
 }
-
+/**
+ * @returns {Promise<void>}
+ */
 async function cleanUpMockLogs() {
     await CallLogModel.destroy({
         where: {
@@ -81,7 +98,6 @@ async function cleanUpMockLogs() {
         }
     });
 }
-
 exports.createUser = createUser;
 exports.deleteUser = deleteUser;
 exports.getCallLog = getCallLog;

package/dist/connector/proxy/engine.d.ts

@@ -0,0 +1,10 @@
+/** @typedef {import('../../types').MapFindContactResponseParams} MapFindContactResponseParams */
+/** @typedef {import('../../types').MapProxyResponseParams} MapProxyResponseParams */
+/** @typedef {import('../../types').PerformProxyRequestParams} PerformProxyRequestParams */
+/** @typedef {import('../../types').ProxyAuthConfig} ProxyAuthConfig */
+/** @typedef {import('../../types').ProxyConfig} ProxyConfig */
+/** @typedef {import('../../types').ProxyContactInfo} ProxyContactInfo */
+/** @typedef {import('../../types').ProxyOperationConfig} ProxyOperationConfig */
+/** @typedef {import('../../types').ProxyResponse} ProxyResponse */
+/** @typedef {Record<string, any>} TemplateContext */
+export {};

package/dist/connector/proxy/engine.js

@@ -0,0 +1,222 @@
+"use strict";
+// @ts-check
+/** @typedef {import('../../types').MapFindContactResponseParams} MapFindContactResponseParams */
+/** @typedef {import('../../types').MapProxyResponseParams} MapProxyResponseParams */
+/** @typedef {import('../../types').PerformProxyRequestParams} PerformProxyRequestParams */
+/** @typedef {import('../../types').ProxyAuthConfig} ProxyAuthConfig */
+/** @typedef {import('../../types').ProxyConfig} ProxyConfig */
+/** @typedef {import('../../types').ProxyContactInfo} ProxyContactInfo */
+/** @typedef {import('../../types').ProxyOperationConfig} ProxyOperationConfig */
+/** @typedef {import('../../types').ProxyResponse} ProxyResponse */
+/** @typedef {Record<string, any>} TemplateContext */
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios = /** @type {any} */ (require('axios'));
+/**
+ * @param {any} obj
+ * @param {string | undefined} path
+ * @returns {any}
+ */
+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;
+}
+/**
+ * @param {any} template
+ * @param {TemplateContext} context
+ * @returns {any}
+ */
+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);
+    });
+}
+/**
+ * @param {any} input
+ * @param {TemplateContext} context
+ * @returns {any}
+ */
+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;
+}
+/**
+ * @param {string | undefined} baseUrl
+ * @param {string | undefined} path
+ * @returns {string | undefined}
+ */
+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(/^\//, '')}`;
+}
+/**
+ * @param {{ auth?: ProxyAuthConfig, context: TemplateContext, authHeader?: string }} params
+ * @returns {Record<string, any>}
+ */
+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;
+}
+/**
+ * @param {{ config: ProxyConfig, operation?: ProxyOperationConfig, authHeader?: string, context: TemplateContext }} params
+ * @returns {Record<string, any>}
+ */
+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;
+}
+/**
+ * @param {PerformProxyRequestParams} params
+ * @returns {Promise<ProxyResponse | null>}
+ */
+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;
+}
+/**
+ * @param {MapFindContactResponseParams} params
+ * @returns {ProxyContactInfo[]}
+ */
+function mapFindContactResponse({ config, response, opName = 'findContact' }) {
+    const map = config.operations?.[opName]?.responseMapping;
+    if (!map)
+        return [];
+    const __ctx = { body: response.data };
+    const list = /** @type {any[]} */ (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
+        };
+    });
+}
+/**
+ * @param {MapProxyResponseParams} params
+ * @returns {{ logId?: string }}
+ */
+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 };
+}
+/**
+ * @param {MapProxyResponseParams} params
+ * @returns {{ callLogInfo: { subject: any, note: any, fullBody: any, fullLogResponse: unknown } }}
+ */
+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
+};

package/dist/connector/proxy/index.d.ts

@@ -0,0 +1,5 @@
+/** @typedef {import('../../types').OperationFailureResult} OperationFailureResult */
+/** @typedef {import('../../types').ProxyConfig} ProxyConfig */
+/** @typedef {import('../../types').ProxyResponse} ProxyResponse */
+/** @typedef {import('../../types').ReturnMessage} ReturnMessage */
+export {};