@app-connect/core 1.7.36 → 1.7.38

package/{handlers → dist/handlers}/auth.js

@@ -1,15 +1,32 @@
-const oauth = require('../lib/oauth');
-const { UserModel } = require('../models/userModel');
-const connectorRegistry = require('../connector/registry');
-const Op = require('sequelize').Op;
-const { RingCentral } = require('../lib/ringcentral');
-const adminCore = require('./admin');
-const { Connector } = require('../models/dynamo/connectorSchema');
+"use strict";
+// @ts-check
+/** @typedef {import('../types').ApiKeyLoginParams} ApiKeyLoginParams */
+/** @typedef {import('../types').AuthHandlerResult} AuthHandlerResult */
+/** @typedef {import('../types').AuthValidationParams} AuthValidationParams */
+/** @typedef {import('../types').AuthValidationResult} AuthValidationResult */
+/** @typedef {import('../types').LicenseStatusParams} LicenseStatusParams */
+/** @typedef {import('../types').OAuthCallbackParams} OAuthCallbackParams */
+/** @typedef {import('../types').RingcentralOAuthCallbackParams} RingcentralOAuthCallbackParams */
+/** @typedef {import('../types').SaveUserInfoParams} SaveUserInfoParams */
+Object.defineProperty(exports, "__esModule", { value: true });
+const oauth = /** @type {any} */ (require('../lib/oauth'));
+const { UserModel: UserModelImport } = require('../models/userModel');
+const UserModel = /** @type {any} */ (UserModelImport);
+const connectorRegistry = /** @type {any} */ (require('../connector/registry'));
+const Op = /** @type {any} */ (require('sequelize').Op);
+const { RingCentral: RingCentralImport } = require('../lib/ringcentral');
+const RingCentral = /** @type {any} */ (RingCentralImport);
+const adminCore = /** @type {any} */ (require('./admin'));
+const { Connector: ConnectorImport } = require('../models/dynamo/connectorSchema');
+const Connector = /** @type {any} */ (ConnectorImport);
 const { handleDatabaseError } = require('../lib/errorHandler');
-const managedAuthCore = require('./managedAuth');
-const managedOAuthCore = require('./managedOAuth');
+const managedAuthCore = /** @type {any} */ (require('./managedAuth'));
+const managedOAuthCore = /** @type {any} */ (require('./managedOAuth'));
 const { getHashValue } = require('../lib/util');
-
+/**
+ * @param {OAuthCallbackParams} params
+ * @returns {Promise<AuthHandlerResult>}
+ */
 async function onOAuthCallback({ platform, hostname, tokenUrl, query, hashedRcExtensionId, isFromMCP = false }) {
     const callbackUri = query.callbackUri;
     const apiUrl = query.apiUrl;
@@ -43,9 +60,8 @@ async function onOAuthCallback({ platform, hostname, tokenUrl, query, hashedRcEx
                 messageType: 'danger',
                 message: oauthInfo.failMessage
             }
-        }
+        };
     }
-
     // Some platforms require different oauth queries, this won't affect normal OAuth process unless CRM module implements getOverridingOAuthOption() method
     let overridingOAuthOption = null;
     if (platformModule.getOverridingOAuthOption != null) {
@@ -56,7 +72,6 @@ async function onOAuthCallback({ platform, hostname, tokenUrl, query, hashedRcEx
     const { accessToken, refreshToken, expires, data } = await oauthApp.code.getToken(callbackUri, overridingOAuthOption);
     const authHeader = `Bearer ${accessToken}`;
     const { successful, platformUserInfo, returnMessage } = await platformModule.getUserInfo({ authHeader, tokenUrl: resolvedTokenUrl, apiUrl, hostname: resolvedHostname, platform, username, callbackUri, query, proxyId, proxyConfig, userEmail, data });
-
     if (successful) {
         let userInfo = null;
         try {
@@ -96,10 +111,13 @@ async function onOAuthCallback({ platform, hostname, tokenUrl, query, hashedRcEx
         return {
             userInfo: null,
             returnMessage
-        }
+        };
     }
 }
-
+/**
+ * @param {ApiKeyLoginParams} params
+ * @returns {Promise<AuthHandlerResult>}
+ */
 async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, rcAccountId, rcExtensionId, connectorId, isPrivate, hashedRcExtensionId, additionalInfo }) {
     const platformModule = connectorRegistry.getConnector(platform);
     let resolvedAdditionalInfo = {
@@ -109,6 +127,7 @@ async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, rcAccountId,
         resolvedAdditionalInfo.apiKey = apiKey;
     }
     let resolvedApiKey = apiKey;
+    /** @type {Array<Record<string, unknown>>} */
     let managedFieldDefinitions = [];
     if (rcAccountId) {
         managedFieldDefinitions = await managedAuthCore.getManagedFieldDefinitions({ rcAccountId, platform, connectorId, isPrivate });
@@ -179,9 +198,12 @@ async function onApiKeyLogin({ platform, hostname, apiKey, proxyId, rcAccountId,
     return {
         userInfo: null,
         returnMessage
-    }
+    };
 }
-
+/**
+ * @param {SaveUserInfoParams} params
+ * @returns {Promise<unknown>}
+ */
 async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken, refreshToken, tokenExpiry, rcAccountId, hashedRcExtensionId, proxyId }) {
     const id = platformUserInfo.id;
     const name = platformUserInfo.name;
@@ -192,23 +214,21 @@ async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken,
     platformAdditionalInfo.proxyId = proxyId;
     if (existingUser) {
         try {
-            await existingUser.update(
-                {
-                    platform,
-                    hostname,
-                    timezoneName,
-                    timezoneOffset,
-                    accessToken,
-                    refreshToken,
-                    tokenExpiry,
-                    rcAccountId,
-                    hashedRcExtensionId,
-                    platformAdditionalInfo: {
-                        ...existingUser.platformAdditionalInfo, // keep existing platformAdditionalInfo
-                        ...platformAdditionalInfo,
-                    }
+            await existingUser.update({
+                platform,
+                hostname,
+                timezoneName,
+                timezoneOffset,
+                accessToken,
+                refreshToken,
+                tokenExpiry,
+                rcAccountId,
+                hashedRcExtensionId,
+                platformAdditionalInfo: {
+                    ...existingUser.platformAdditionalInfo, // keep existing platformAdditionalInfo
+                    ...platformAdditionalInfo,
                 }
-            );
+            });
         }
         catch (error) {
             return handleDatabaseError(error, 'Error saving user info');
@@ -240,7 +260,10 @@ async function saveUserInfo({ platformUserInfo, platform, hostname, accessToken,
         name
     };
 }
-
+/**
+ * @param {LicenseStatusParams} params
+ * @returns {Promise<unknown>}
+ */
 async function getLicenseStatus({ userId, platform }) {
     const user = await UserModel.findByPk(userId);
     if (!user) {
@@ -248,14 +271,17 @@ async function getLicenseStatus({ userId, platform }) {
             isLicenseValid: false,
             licenseStatus: 'Invalid (User not found)',
             licenseStatusDescription: ''
-        }
+        };
     }
     const platformModule = connectorRegistry.getConnector(platform);
     const licenseStatus = await platformModule.getLicenseStatus({ userId, platform, user });
     return licenseStatus;
 }
-
 // Just for oauth ATM
+/**
+ * @param {AuthValidationParams} params
+ * @returns {Promise<AuthValidationResult>}
+ */
 async function authValidation({ platform, userId }) {
     let existingUser = await UserModel.findOne({
         where: {
@@ -283,18 +309,21 @@ async function authValidation({ platform, userId }) {
             returnMessage,
             status,
             failReason: successful ? '' : 'CRM. API failed'
-        }
+        };
     }
     else {
         return {
             successful: false,
             status: 404,
             failReason: 'App Connect. User not found in database'
-        }
+        };
     }
 }
-
 // Ringcentral
+/**
+ * @param {RingcentralOAuthCallbackParams} params
+ * @returns {Promise<void>}
+ */
 async function onRingcentralOAuthCallback({ code, rcAccountId }) {
     if (!process.env.RINGCENTRAL_SERVER || !process.env.RINGCENTRAL_CLIENT_ID || !process.env.RINGCENTRAL_CLIENT_SECRET) {
         return;
@@ -314,7 +343,6 @@ async function onRingcentralOAuthCallback({ code, rcAccountId }) {
         adminTokenExpiry: expire_time
     });
 }
-
 exports.onOAuthCallback = onOAuthCallback;
 exports.onApiKeyLogin = onApiKeyLogin;
 exports.authValidation = authValidation;

package/dist/handlers/calldown.d.ts

@@ -0,0 +1,10 @@
+/** @typedef {import('../types').CallDownJwtData} CallDownJwtData */
+/** @typedef {import('../types').CallDownListParams} CallDownListParams */
+/** @typedef {import('../types').CallDownListResult} CallDownListResult */
+/** @typedef {import('../types').CallDownMarkCalledParams} CallDownMarkCalledParams */
+/** @typedef {import('../types').CallDownOperationResult} CallDownOperationResult */
+/** @typedef {import('../types').CallDownRecordParams} CallDownRecordParams */
+/** @typedef {import('../types').CallDownScheduleParams} CallDownScheduleParams */
+/** @typedef {import('../types').CallDownScheduleResult} CallDownScheduleResult */
+/** @typedef {import('../types').CallDownUpdateParams} CallDownUpdateParams */
+export {};

package/dist/handlers/calldown.js

@@ -0,0 +1,134 @@
+"use strict";
+// @ts-check
+/** @typedef {import('../types').CallDownJwtData} CallDownJwtData */
+/** @typedef {import('../types').CallDownListParams} CallDownListParams */
+/** @typedef {import('../types').CallDownListResult} CallDownListResult */
+/** @typedef {import('../types').CallDownMarkCalledParams} CallDownMarkCalledParams */
+/** @typedef {import('../types').CallDownOperationResult} CallDownOperationResult */
+/** @typedef {import('../types').CallDownRecordParams} CallDownRecordParams */
+/** @typedef {import('../types').CallDownScheduleParams} CallDownScheduleParams */
+/** @typedef {import('../types').CallDownScheduleResult} CallDownScheduleResult */
+/** @typedef {import('../types').CallDownUpdateParams} CallDownUpdateParams */
+Object.defineProperty(exports, "__esModule", { value: true });
+const { UserModel: UserModelImport } = require('../models/userModel');
+const UserModel = /** @type {any} */ (UserModelImport);
+const { CallDownListModel: CallDownListModelImport } = require('../models/callDownListModel');
+const CallDownListModel = /** @type {any} */ (CallDownListModelImport);
+const { Op: OpImport } = require('sequelize');
+const Op = /** @type {any} */ (OpImport);
+const jwt = /** @type {any} */ (require('../lib/jwt'));
+const { handleDatabaseError } = require('../lib/errorHandler');
+/**
+ * @param {CallDownScheduleParams} params
+ * @returns {Promise<CallDownScheduleResult>}
+ */
+async function schedule({ jwtToken, body }) {
+    const unAuthData = /** @type {CallDownJwtData | null} */ (jwt.decodeJwt(jwtToken));
+    if (!unAuthData?.id)
+        throw new Error('Unauthorized');
+    const user = await UserModel.findByPk(unAuthData.id);
+    if (!user)
+        throw new Error('User not found');
+    const crypto = require('crypto');
+    const recordId = crypto.randomBytes(16).toString('hex');
+    const payload = {
+        id: recordId,
+        userId: user.id,
+        contactId: body.contactId?.toString?.() ?? body.contactId,
+        contactType: body.contactType ?? 'contact',
+        contactName: body.contactName ?? '',
+        phoneNumber: body.phoneNumber ?? '',
+        status: 'scheduled',
+        scheduledAt: body.scheduledAt ? new Date(body.scheduledAt) : null,
+        lastCallAt: null
+    };
+    await CallDownListModel.create(payload);
+    return { id: recordId };
+}
+/**
+ * @param {CallDownListParams} params
+ * @returns {Promise<CallDownListResult>}
+ */
+async function list({ jwtToken, status }) {
+    const unAuthData = /** @type {CallDownJwtData | null} */ (jwt.decodeJwt(jwtToken));
+    if (!unAuthData?.id)
+        throw new Error('Unauthorized');
+    const statusParam = (status || 'All').toString().toLowerCase();
+    /** @type {{ userId: string | number, status?: unknown }} */
+    const whereClause = { userId: unAuthData.id };
+    if (statusParam === 'called')
+        whereClause.status = 'called';
+    else if (['not called', 'not_called', 'notcalled'].includes(statusParam))
+        whereClause.status = { [Op.ne]: 'called' };
+    const items = await CallDownListModel.findAll({ where: whereClause, order: [["scheduledAt", "ASC"]] });
+    return { items };
+}
+/**
+ * @param {CallDownRecordParams} params
+ * @returns {Promise<CallDownOperationResult>}
+ */
+async function remove({ jwtToken, id }) {
+    const unAuthData = /** @type {CallDownJwtData | null} */ (jwt.decodeJwt(jwtToken));
+    if (!unAuthData?.id)
+        throw new Error('Unauthorized');
+    const deleted = await CallDownListModel.destroy({ where: { id, userId: unAuthData.id } });
+    if (!deleted)
+        throw new Error('Not found');
+    return { successful: true };
+}
+/**
+ * @param {CallDownMarkCalledParams} params
+ * @returns {Promise<CallDownOperationResult>}
+ */
+async function markCalled({ jwtToken, id, lastCallAt }) {
+    const unAuthData = /** @type {CallDownJwtData | null} */ (jwt.decodeJwt(jwtToken));
+    if (!unAuthData?.id)
+        throw new Error('Unauthorized');
+    const when = lastCallAt ? new Date(/** @type {any} */ (lastCallAt)) : new Date();
+    try {
+        const [affected] = await CallDownListModel.update({ status: 'called', lastCallAt: when }, { where: { id, userId: unAuthData.id } });
+        if (!affected)
+            throw new Error('Not found');
+        return { successful: true };
+    }
+    catch (error) {
+        return handleDatabaseError(error, 'Error marking call as called', { id, userId: unAuthData.id });
+    }
+}
+/**
+ * @param {CallDownUpdateParams} params
+ * @returns {Promise<CallDownOperationResult>}
+ */
+async function update({ jwtToken, id, updateData }) {
+    const unAuthData = /** @type {CallDownJwtData | null} */ (jwt.decodeJwt(jwtToken));
+    if (!unAuthData?.id)
+        throw new Error('Unauthorized');
+    // Prepare the update object with only valid fields
+    const allowedFields = ['contactId', 'contactType', 'contactName', 'phoneNumber', 'status', 'scheduledAt', 'lastCallAt', 'note'];
+    /** @type {Record<string, unknown>} */
+    const updateObject = {};
+    // Filter and prepare update data
+    Object.keys(updateData).forEach(key => {
+        if (allowedFields.includes(key)) {
+            let value = updateData[key];
+            // Handle date fields
+            if ((key === 'scheduledAt' || key === 'lastCallAt') && value) {
+                value = new Date(/** @type {any} */ (value));
+            }
+            updateObject[key] = value;
+        }
+    });
+    // If no valid fields to update, throw error
+    if (Object.keys(updateObject).length === 0) {
+        throw new Error('No valid fields to update');
+    }
+    const [affected] = await CallDownListModel.update(updateObject, { where: { id, userId: unAuthData.id } });
+    if (!affected)
+        throw new Error('Not found');
+    return { successful: true };
+}
+exports.schedule = schedule;
+exports.list = list;
+exports.remove = remove;
+exports.markCalled = markCalled;
+exports.update = update;

package/dist/handlers/contact.d.ts

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

package/{handlers → dist/handlers}/contact.js

@@ -1,10 +1,30 @@
-const oauth = require('../lib/oauth');
-const { UserModel } = require('../models/userModel');
-const connectorRegistry = require('../connector/registry');
-const { Connector } = require('../models/dynamo/connectorSchema');
-const { handleApiError } = require('../lib/errorHandler');
-const { AccountDataModel } = require('../models/accountDataModel');
-
+"use strict";
+// @ts-check
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @typedef {import('../types').AccountContactDataRecord} AccountContactDataRecord */
+/** @typedef {import('../types').ContactConnectorImplementation} ContactConnectorImplementation */
+/** @typedef {import('../types').ContactHandlerResult} ContactHandlerResult */
+/** @typedef {import('../types').ContactHandlerUser} ContactHandlerUser */
+/** @typedef {import('../types').CreateContactParams} CreateContactParams */
+/** @typedef {import('../types').FindContactParams} FindContactParams */
+/** @typedef {import('../types').FindContactWithNameParams} FindContactWithNameParams */
+/** @typedef {import('../types').OAuthInfo} OAuthInfo */
+/** @typedef {import('../types').ProviderError} ProviderError */
+/** @typedef {import('../types').ProxyConfig} ProxyConfig */
+const oauth = /** @type {{ getOAuthApp(info: OAuthInfo): any, checkAndRefreshAccessToken(oauthApp: any, user: ContactHandlerUser): Promise<ContactHandlerUser | null> }} */ (require('../lib/oauth'));
+const { UserModel: RawUserModel } = require('../models/userModel');
+const UserModel = /** @type {{ findOne(options: Record<string, unknown>): Promise<ContactHandlerUser | null> }} */ (RawUserModel);
+const connectorRegistry = /** @type {{ getConnector(platform: string): ContactConnectorImplementation }} */ ( /** @type {unknown} */(require('../connector/registry')));
+const { Connector: RawConnector } = require('../models/dynamo/connectorSchema');
+const Connector = /** @type {{ getProxyConfig(proxyId: string): Promise<ProxyConfig | null> }} */ ( /** @type {unknown} */(RawConnector));
+const { handleApiError: rawHandleApiError } = require('../lib/errorHandler');
+const handleApiError = /** @type {(error: unknown, platform: string, operation: string, context?: Record<string, unknown>) => ContactHandlerResult} */ (rawHandleApiError);
+const { AccountDataModel: RawAccountDataModel } = require('../models/accountDataModel');
+const AccountDataModel = /** @type {{ findOne(options: Record<string, unknown>): Promise<AccountContactDataRecord | null>, create(values: Record<string, unknown>): Promise<AccountContactDataRecord> }} */ (RawAccountDataModel);
+/**
+ * @param {FindContactParams} params
+ * @returns {Promise<ContactHandlerResult>}
+ */
 async function findContact({ platform, userId, phoneNumber, overridingFormat, isExtension, tracer, isForceRefreshAccountData = false }) {
     tracer?.trace('handler.findContact:entered', { platform, userId, phoneNumber });
     try {
@@ -15,7 +35,6 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
             }
         });
         tracer?.trace('handler.findContact:userFound', { user });
-
         if (!user || !user.accessToken) {
             tracer?.trace('handler.findContact:noUser', { userId });
             return {
@@ -34,7 +53,7 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
                 platformName: platform,
                 dataKey: `contact-${phoneNumber}`
             }
-        })
+        });
         if (!isForceRefreshAccountData) {
             if (existingMatchedContactInfo) {
                 console.log('found existing matched contact info in account data');
@@ -50,7 +69,6 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
         const platformModule = connectorRegistry.getConnector(platform);
         const authType = await platformModule.getAuthType({ proxyId, proxyConfig });
         tracer?.trace('handler.findContact:authType', { authType });
-
         let authHeader = '';
         switch (authType) {
             case 'oauth':
@@ -65,7 +83,7 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
                             ttl: 5000
                         },
                         isRevokeUserSession: true
-                    }
+                    };
                 }
                 authHeader = `Bearer ${user.accessToken}`;
                 tracer?.trace('handler.findContact:oauthAuth', { authHeader });
@@ -76,10 +94,8 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
                 tracer?.trace('handler.findContact:apiKeyAuth', {});
                 break;
         }
-
         const { successful, matchedContactInfo, returnMessage, extraDataTracking } = await platformModule.findContact({ user, authHeader, phoneNumber, overridingFormat, isExtension, proxyConfig, tracer, isForceRefreshAccountData });
         tracer?.trace('handler.findContact:platformFindResult', { successful, matchedContactInfo });
-
         const matchedNonNewContacts = matchedContactInfo?.filter(c => !c.isNewContact) ?? [];
         if (matchedContactInfo != null && matchedNonNewContacts.length > 0) {
             tracer?.trace('handler.findContact:contactsFound', { count: matchedContactInfo.length });
@@ -115,37 +131,40 @@ async function findContact({ platform, userId, phoneNumber, overridingFormat, is
                     returnMessage,
                     extraDataTracking,
                     contact: matchedContactInfo,
-                }
+                };
             }
             return {
                 successful,
-                returnMessage:
-                {
+                returnMessage: {
                     message: `Contact not found`,
                     messageType: 'warning',
                     details: [{
-                        title: 'Details',
-                        items: [
-                            {
-                                id: '1',
-                                type: 'text',
-                                text: `A contact with the phone number ${phoneNumber} could not be found in your ${platform} account.`
-                            }
-                        ]
-                    }],
+                            title: 'Details',
+                            items: [
+                                {
+                                    id: '1',
+                                    type: 'text',
+                                    text: `A contact with the phone number ${phoneNumber} could not be found in your ${platform} account.`
+                                }
+                            ]
+                        }],
                     ttl: 5000
                 },
                 contact: matchedContactInfo,
                 extraDataTracking
             };
         }
-    } catch (e) {
-        tracer?.traceError('handler.findContact:error', e, { platform, statusCode: e.response?.status });
-        return handleApiError(e, platform, 'findContact', { userId, overridingFormat, isExtension });
-
+    }
+    catch (e) {
+        const error = /** @type {ProviderError} */ (e);
+        tracer?.traceError('handler.findContact:error', error, { platform, statusCode: error.response?.status });
+        return handleApiError(error, platform, 'findContact', { userId, overridingFormat, isExtension });
     }
 }
-
+/**
+ * @param {CreateContactParams} params
+ * @returns {Promise<ContactHandlerResult>}
+ */
 async function createContact({ platform, userId, phoneNumber, newContactName, newContactType, additionalSubmission }) {
     try {
         let user = await UserModel.findOne({
@@ -178,7 +197,7 @@ async function createContact({ platform, userId, phoneNumber, newContactName, ne
                             ttl: 5000
                         },
                         isRevokeUserSession: true
-                    }
+                    };
                 }
                 authHeader = `Bearer ${user.accessToken}`;
                 break;
@@ -194,11 +213,15 @@ async function createContact({ platform, userId, phoneNumber, newContactName, ne
         else {
             return { successful: false, returnMessage };
         }
-    } catch (e) {
+    }
+    catch (e) {
         return handleApiError(e, platform, 'createContact', { userId, phoneNumber, newContactName, newContactType, additionalSubmission });
     }
 }
-
+/**
+ * @param {FindContactWithNameParams} params
+ * @returns {Promise<ContactHandlerResult>}
+ */
 async function findContactWithName({ platform, userId, name }) {
     try {
         let user = await UserModel.findOne({
@@ -238,7 +261,7 @@ async function findContactWithName({ platform, userId, name }) {
                             ttl: 5000
                         },
                         isRevokeUserSession: true
-                    }
+                    };
                 }
                 authHeader = `Bearer ${user.accessToken}`;
                 break;
@@ -257,12 +280,11 @@ async function findContactWithName({ platform, userId, name }) {
                     successful,
                     returnMessage,
                     contact: matchedContactInfo,
-                }
+                };
             }
             return {
                 successful,
-                returnMessage:
-                {
+                returnMessage: {
                     message: `No contact found with name ${name} `,
                     messageType: 'warning',
                     ttl: 5000
@@ -270,11 +292,11 @@ async function findContactWithName({ platform, userId, name }) {
                 contact: matchedContactInfo
             };
         }
-    } catch (e) {
+    }
+    catch (e) {
         return handleApiError(e, platform, 'findContactWithName', { userId, name });
     }
 }
-
 exports.findContact = findContact;
 exports.createContact = createContact;
 exports.findContactWithName = findContactWithName;

package/dist/handlers/disposition.d.ts

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

package/{handlers → dist/handlers}/disposition.js

@@ -1,11 +1,22 @@
-const { CallLogModel } = require('../models/callLogModel');
-const { UserModel } = require('../models/userModel');
-const oauth = require('../lib/oauth');
-const connectorRegistry = require('../connector/registry');
-const { Connector } = require('../models/dynamo/connectorSchema');
+"use strict";
+// @ts-check
+Object.defineProperty(exports, "__esModule", { value: true });
+const { CallLogModel: CallLogModelImport } = require('../models/callLogModel');
+const { UserModel: UserModelImport } = require('../models/userModel');
+const oauth = /** @type {any} */ (require('../lib/oauth'));
+const connectorRegistry = /** @type {any} */ (require('../connector/registry'));
+const { Connector: ConnectorImport } = require('../models/dynamo/connectorSchema');
 const { handleApiError } = require('../lib/errorHandler');
 const { buildCallLogSessionWhere } = require('../lib/callLogLookup');
-
+const CallLogModel = /** @type {any} */ (CallLogModelImport);
+const UserModel = /** @type {any} */ (UserModelImport);
+const Connector = /** @type {any} */ (ConnectorImport);
+/** @typedef {import('../types').UpsertCallDispositionParams} UpsertCallDispositionParams */
+/** @typedef {import('../types').UpsertCallDispositionResult} UpsertCallDispositionResult */
+/**
+ * @param {UpsertCallDispositionParams} params
+ * @returns {Promise<UpsertCallDispositionResult>}
+ */
 async function upsertCallDisposition({ platform, userId, sessionId, extensionNumber, hashedExtensionId, dispositions }) {
     try {
         const existingCallLog = await CallLogModel.findOne({
@@ -23,7 +34,7 @@ async function upsertCallDisposition({ platform, userId, sessionId, extensionNum
                     messageType: 'warning',
                     ttl: 3000
                 }
-            }
+            };
         }
         let user = await UserModel.findByPk(userId);
         if (!user) {
@@ -34,7 +45,7 @@ async function upsertCallDisposition({ platform, userId, sessionId, extensionNum
                     messageType: 'warning',
                     ttl: 3000
                 }
-            }
+            };
         }
         const proxyId = user.platformAdditionalInfo?.proxyId;
         let proxyConfig = null;
@@ -57,7 +68,7 @@ async function upsertCallDisposition({ platform, userId, sessionId, extensionNum
                             ttl: 5000
                         },
                         isRevokeUserSession: true
-                    }
+                    };
                 }
                 authHeader = `Bearer ${user.accessToken}`;
                 break;
@@ -79,5 +90,4 @@ async function upsertCallDisposition({ platform, userId, sessionId, extensionNum
         return handleApiError(e, platform, 'upsertCallDisposition', { userId, sessionId, extensionNumber, hashedExtensionId, dispositions });
     }
 }
-
 exports.upsertCallDisposition = upsertCallDisposition;

package/dist/handlers/log.d.ts

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