@sipgate/integration-bridge 1.0.36 → 1.0.40

package/dist/models/controller.model.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Controller = void 0;
 const lodash_1 = require("lodash");
@@ -23,13 +14,15 @@ const pubsub_contacts_message_model_1 = require("./pubsub/pubsub-contacts-messag
 const anonymize_key_1 = require("../util/anonymize-key");
 const CONTACT_FETCH_TIMEOUT = 5000;
 class Controller {
+    adapter;
+    contactCache;
+    pubSubContactStreamingClient = null;
+    pubSubIntegrationEventsClient = null;
+    additionalPubSubContactStreamingClient = null;
+    integrationName = 'UNKNOWN';
+    // used for garbage collection reasons, to prevent long running promises from getting canceled
+    streamingPromises = new Map();
     constructor(adapter, contactCache) {
-        this.pubSubContactStreamingClient = null;
-        this.pubSubIntegrationEventsClient = null;
-        this.additionalPubSubContactStreamingClient = null;
-        this.integrationName = 'UNKNOWN';
-        // used for garbage collection reasons, to prevent long running promises from getting canceled
-        this.streamingPromises = new Map();
         this.adapter = adapter;
         this.contactCache = contactCache;
         if (this.adapter.streamContacts) {
@@ -48,7 +41,7 @@ class Controller {
     }
     initContactStreaming() {
         const { PUBSUB_TOPIC_NAME: topicNameLegacy, PUBSUB_TOPIC_NAME_CONTACT_STREAMING: topicName, PUBSUB_ADDITIONAL_TOPIC_NAME: additionalTopicName, } = process.env;
-        const topicNameProvided = topicName !== null && topicName !== void 0 ? topicName : topicNameLegacy;
+        const topicNameProvided = topicName ?? topicNameLegacy;
         if (!topicNameProvided) {
             throw new Error('No PUBSUB_TOPIC_NAME_CONTACT_STREAMING provided.');
         }
@@ -67,388 +60,371 @@ class Controller {
         this.pubSubIntegrationEventsClient = new _1.PubSubClient(topicName);
         (0, logger_util_1.infoLogger)('Controller', `Initialized PubSub client for topic ${topicName}`);
     }
-    isValidToken(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig } = req;
-            if (!providerConfig) {
-                throw new _1.ServerError(400, 'Missing parameters');
+    async isValidToken(req, res, next) {
+        const { providerConfig } = req;
+        if (!providerConfig) {
+            throw new _1.ServerError(400, 'Missing parameters');
+        }
+        try {
+            (0, logger_util_1.infoLogger)('isValidToken', 'START', providerConfig.apiKey);
+            if (!this.adapter.isValidToken) {
+                throw new _1.ServerError(501, 'Token validation function is not implemented');
             }
-            try {
-                (0, logger_util_1.infoLogger)('isValidToken', 'START', providerConfig.apiKey);
-                if (!this.adapter.isValidToken) {
-                    throw new _1.ServerError(501, 'Token validation function is not implemented');
-                }
-                const isTokenValid = yield this.adapter.isValidToken(providerConfig);
-                if (!isTokenValid) {
-                    throw new _1.ServerError(401, 'Token is not valid');
+            const isTokenValid = await this.adapter.isValidToken(providerConfig);
+            if (!isTokenValid) {
+                throw new _1.ServerError(401, 'Token is not valid');
+            }
+            (0, logger_util_1.infoLogger)('isValidToken', 'END', providerConfig.apiKey);
+            res.status(200).send('OK');
+        }
+        catch (error) {
+            // prevent logging of refresh errors
+            if (error instanceof _1.ServerError &&
+                error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
+                next(error);
+                return;
+            }
+            (0, logger_util_1.errorLogger)('isValidToken', 'Could not validate token:', providerConfig.apiKey, error);
+            next(error);
+        }
+    }
+    async getContacts(req, res, next) {
+        const { providerConfig } = req;
+        if (!providerConfig) {
+            throw new _1.ServerError(400, 'Missing parameters');
+        }
+        try {
+            (0, logger_util_1.infoLogger)('getContacts', 'START', providerConfig.apiKey);
+            const fetchContacts = async () => {
+                if (!this.adapter.getContacts) {
+                    throw new _1.ServerError(501, 'Fetching contacts is not implemented');
+                }
+                (0, logger_util_1.infoLogger)('getContacts', `Fetching contacts…`, providerConfig.apiKey);
+                const fetchedContacts = await this.adapter.getContacts(providerConfig);
+                const { error: parsingError, data: parsedContacts } = schemas_1.contactsGetSchema.safeParse(fetchedContacts);
+                if (parsingError)
+                    throw new _1.ServerError(500, `Invalid contacts received: ${parsingError.message}`);
+                return parsedContacts.map((contact) => (0, contact_util_1.sanitizeContact)(contact, providerConfig.locale));
+            };
+            const fetcherPromise = this.contactCache
+                ? this.contactCache.get(providerConfig.apiKey, fetchContacts)
+                : fetchContacts();
+            const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve('TIMEOUT'), CONTACT_FETCH_TIMEOUT));
+            const raceResult = await Promise.race([fetcherPromise, timeoutPromise]);
+            if (raceResult === 'TIMEOUT') {
+                (0, logger_util_1.infoLogger)('getContacts', `Fetching too slow, returning empty array.`, providerConfig.apiKey);
+            }
+            const responseContacts = Array.isArray(raceResult)
+                ? raceResult
+                : [];
+            const contactsCount = responseContacts.length;
+            (0, logger_util_1.infoLogger)('getContacts', `Found ${contactsCount} cached contacts`, providerConfig.apiKey);
+            if (!Array.isArray(raceResult) &&
+                (raceResult === 'TIMEOUT' ||
+                    raceResult.state === cache_item_state_model_1.CacheItemStateType.FETCHING)) {
+                res.header('X-Fetching-State', 'pending');
+            }
+            if (this.adapter.getToken && req.providerConfig) {
+                try {
+                    const { apiKey } = await this.adapter.getToken(req.providerConfig);
+                    res.header('X-Provider-Key', apiKey);
                 }
-                (0, logger_util_1.infoLogger)('isValidToken', 'END', providerConfig.apiKey);
-                res.status(200).send('OK');
-            }
-            catch (error) {
-                // prevent logging of refresh errors
-                if (error instanceof _1.ServerError &&
-                    error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
-                    next(error);
-                    return;
+                catch (error) {
+                    (0, logger_util_1.errorLogger)('getContacts', 'Could not get and refresh token', providerConfig.apiKey, error);
                 }
-                (0, logger_util_1.errorLogger)('isValidToken', 'Could not validate token:', providerConfig.apiKey, error);
+            }
+            (0, logger_util_1.infoLogger)('getContacts', 'END', providerConfig.apiKey);
+            res.status(200).send(responseContacts);
+        }
+        catch (error) {
+            // prevent logging of refresh errors
+            if (error instanceof _1.ServerError &&
+                error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
                 next(error);
+                return;
             }
-        });
+            (0, logger_util_1.errorLogger)('getContacts', 'Could not get contacts:', providerConfig.apiKey, error);
+            next(error);
+        }
     }
-    getContacts(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig } = req;
+    async streamContacts(req, res, next) {
+        const { providerConfig } = req;
+        try {
             if (!providerConfig) {
                 throw new _1.ServerError(400, 'Missing parameters');
             }
-            try {
-                (0, logger_util_1.infoLogger)('getContacts', 'START', providerConfig.apiKey);
-                const fetchContacts = () => __awaiter(this, void 0, void 0, function* () {
-                    if (!this.adapter.getContacts) {
-                        throw new _1.ServerError(501, 'Fetching contacts is not implemented');
-                    }
-                    (0, logger_util_1.infoLogger)('getContacts', `Fetching contacts…`, providerConfig.apiKey);
-                    const fetchedContacts = yield this.adapter.getContacts(providerConfig);
-                    const { error: parsingError, data: parsedContacts } = schemas_1.contactsGetSchema.safeParse(fetchedContacts);
-                    if (parsingError)
+            const { userId } = providerConfig;
+            if (!userId) {
+                throw new _1.ServerError(400, 'Missing user ID');
+            }
+            const timestamp = Date.now();
+            const orderingKey = `${userId}:${timestamp}`;
+            (0, logger_util_1.infoLogger)('streamContacts', `[${orderingKey}] Starting contact streaming`, providerConfig.apiKey);
+            const publishContacts = async (contacts) => {
+                try {
+                    const { error: parsingError, data: parsedContacts } = schemas_1.contactsGetSchema.safeParse(contacts);
+                    if (parsingError) {
                         throw new _1.ServerError(500, `Invalid contacts received: ${parsingError.message}`);
-                    return parsedContacts.map((contact) => (0, contact_util_1.sanitizeContact)(contact, providerConfig.locale));
-                });
-                const fetcherPromise = this.contactCache
-                    ? this.contactCache.get(providerConfig.apiKey, fetchContacts)
-                    : fetchContacts();
-                const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve('TIMEOUT'), CONTACT_FETCH_TIMEOUT));
-                const raceResult = yield Promise.race([fetcherPromise, timeoutPromise]);
-                if (raceResult === 'TIMEOUT') {
-                    (0, logger_util_1.infoLogger)('getContacts', `Fetching too slow, returning empty array.`, providerConfig.apiKey);
-                }
-                const responseContacts = Array.isArray(raceResult)
-                    ? raceResult
-                    : [];
-                const contactsCount = responseContacts.length;
-                (0, logger_util_1.infoLogger)('getContacts', `Found ${contactsCount} cached contacts`, providerConfig.apiKey);
-                if (!Array.isArray(raceResult) &&
-                    (raceResult === 'TIMEOUT' ||
-                        raceResult.state === cache_item_state_model_1.CacheItemStateType.FETCHING)) {
-                    res.header('X-Fetching-State', 'pending');
-                }
-                if (this.adapter.getToken && req.providerConfig) {
-                    try {
-                        const { apiKey } = yield this.adapter.getToken(req.providerConfig);
-                        res.header('X-Provider-Key', apiKey);
-                    }
-                    catch (error) {
-                        (0, logger_util_1.errorLogger)('getContacts', 'Could not get and refresh token', providerConfig.apiKey, error);
                     }
-                }
-                (0, logger_util_1.infoLogger)('getContacts', 'END', providerConfig.apiKey);
-                res.status(200).send(responseContacts);
-            }
-            catch (error) {
-                // prevent logging of refresh errors
-                if (error instanceof _1.ServerError &&
-                    error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
-                    next(error);
-                    return;
-                }
-                (0, logger_util_1.errorLogger)('getContacts', 'Could not get contacts:', providerConfig.apiKey, error);
-                next(error);
-            }
-        });
-    }
-    streamContacts(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig } = req;
-            try {
-                if (!providerConfig) {
-                    throw new _1.ServerError(400, 'Missing parameters');
-                }
-                const { userId } = providerConfig;
-                if (!userId) {
-                    throw new _1.ServerError(400, 'Missing user ID');
-                }
-                const timestamp = Date.now();
-                const orderingKey = `${userId}:${timestamp}`;
-                (0, logger_util_1.infoLogger)('streamContacts', `[${orderingKey}] Starting contact streaming`, providerConfig.apiKey);
-                const publishContacts = (contacts) => __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b;
-                    try {
-                        const { error: parsingError, data: parsedContacts } = schemas_1.contactsGetSchema.safeParse(contacts);
-                        if (parsingError) {
-                            throw new _1.ServerError(500, `Invalid contacts received: ${parsingError.message}`);
-                        }
-                        yield ((_a = this.pubSubContactStreamingClient) === null || _a === void 0 ? void 0 : _a.publishMessage({
-                            userId,
-                            timestamp,
-                            contacts: parsedContacts.map((contact) => (0, contact_util_1.sanitizeContact)(contact, providerConfig.locale)),
-                            state: pubsub_contacts_message_model_1.PubSubContactsState.IN_PROGRESS,
-                            integrationName: this.integrationName,
-                        }, orderingKey));
-                        // todo: remove as soon as platypus goes live
-                        yield ((_b = this.additionalPubSubContactStreamingClient) === null || _b === void 0 ? void 0 : _b.publishMessage({
-                            userId,
-                            timestamp,
-                            contacts: contacts.map((contact) => (0, contact_util_1.sanitizeContact)(contact, providerConfig.locale)),
-                            state: pubsub_contacts_message_model_1.PubSubContactsState.IN_PROGRESS,
-                            integrationName: this.integrationName,
-                        }, orderingKey));
-                    }
-                    catch (error) {
-                        if (error instanceof _1.ServerError) {
-                            (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not publish contacts`, providerConfig.apiKey, { message: error.message, status: error.status });
-                            return;
-                        }
-                        (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not publish contacts (${error})`, providerConfig.apiKey);
-                    }
-                });
-                const streamContacts = () => __awaiter(this, void 0, void 0, function* () {
-                    if (!this.adapter.streamContacts) {
-                        throw new _1.ServerError(501, 'Streaming contacts is not implemented');
-                    }
-                    const iterator = this.adapter.streamContacts(providerConfig);
-                    let result;
-                    do {
-                        result = yield iterator.next();
-                        const { value: contacts } = result;
-                        if (contacts && contacts.length > 0)
-                            yield publishContacts(contacts);
-                    } while (!result.done);
-                });
-                const streamingPromise = streamContacts()
-                    .then(() => {
-                    var _a, _b;
-                    (_a = this.additionalPubSubContactStreamingClient) === null || _a === void 0 ? void 0 : _a.publishMessage({
-                        userId: providerConfig.userId,
+                    await this.pubSubContactStreamingClient?.publishMessage({
+                        userId,
                         timestamp,
-                        contacts: [],
-                        state: pubsub_contacts_message_model_1.PubSubContactsState.COMPLETE,
+                        contacts: parsedContacts.map((contact) => (0, contact_util_1.sanitizeContact)(contact, providerConfig.locale)),
+                        state: pubsub_contacts_message_model_1.PubSubContactsState.IN_PROGRESS,
                         integrationName: this.integrationName,
                     }, orderingKey);
-                    return (_b = this.pubSubContactStreamingClient) === null || _b === void 0 ? void 0 : _b.publishMessage({
-                        userId: providerConfig.userId,
+                    // todo: remove as soon as platypus goes live
+                    await this.additionalPubSubContactStreamingClient?.publishMessage({
+                        userId,
                         timestamp,
-                        contacts: [],
-                        state: pubsub_contacts_message_model_1.PubSubContactsState.COMPLETE,
+                        contacts: contacts.map((contact) => (0, contact_util_1.sanitizeContact)(contact, providerConfig.locale)),
+                        state: pubsub_contacts_message_model_1.PubSubContactsState.IN_PROGRESS,
                         integrationName: this.integrationName,
                     }, orderingKey);
-                })
-                    .catch((error) => __awaiter(this, void 0, void 0, function* () {
-                    var _c, _d;
-                    (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not stream contacts`, providerConfig.apiKey, error);
-                    (_c = this.additionalPubSubContactStreamingClient) === null || _c === void 0 ? void 0 : _c.publishMessage({
-                        userId: providerConfig.userId,
-                        timestamp,
-                        contacts: [],
-                        state: pubsub_contacts_message_model_1.PubSubContactsState.FAILED,
-                        integrationName: this.integrationName,
-                    }, orderingKey);
-                    return (_d = this.pubSubContactStreamingClient) === null || _d === void 0 ? void 0 : _d.publishMessage({
-                        userId: providerConfig.userId,
-                        timestamp,
-                        contacts: [],
-                        state: pubsub_contacts_message_model_1.PubSubContactsState.FAILED,
-                        integrationName: this.integrationName,
-                    }, orderingKey);
-                }))
-                    .catch((error) => {
-                    (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not publish failed message`, providerConfig.apiKey, error);
-                })
-                    .finally(() => this.streamingPromises.delete(`${userId}:${timestamp}`));
-                this.streamingPromises.set(`${userId}:${timestamp}`, streamingPromise);
-                if (this.adapter.getToken && req.providerConfig) {
-                    try {
-                        const { apiKey } = yield this.adapter.getToken(req.providerConfig);
-                        res.header('X-Provider-Key', apiKey);
-                    }
-                    catch (error) {
-                        (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not get and refresh token`, providerConfig.apiKey, error);
+                }
+                catch (error) {
+                    if (error instanceof _1.ServerError) {
+                        (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not publish contacts`, providerConfig.apiKey, { message: error.message, status: error.status });
+                        return;
                     }
+                    (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not publish contacts (${error})`, providerConfig.apiKey);
+                }
+            };
+            const streamContacts = async () => {
+                if (!this.adapter.streamContacts) {
+                    throw new _1.ServerError(501, 'Streaming contacts is not implemented');
+                }
+                const iterator = this.adapter.streamContacts(providerConfig);
+                let result;
+                do {
+                    result = await iterator.next();
+                    const { value: contacts } = result;
+                    if (contacts && contacts.length > 0)
+                        await publishContacts(contacts);
+                } while (!result.done);
+            };
+            const streamingPromise = streamContacts()
+                .then(() => {
+                this.additionalPubSubContactStreamingClient?.publishMessage({
+                    userId: providerConfig.userId,
+                    timestamp,
+                    contacts: [],
+                    state: pubsub_contacts_message_model_1.PubSubContactsState.COMPLETE,
+                    integrationName: this.integrationName,
+                }, orderingKey);
+                return this.pubSubContactStreamingClient?.publishMessage({
+                    userId: providerConfig.userId,
+                    timestamp,
+                    contacts: [],
+                    state: pubsub_contacts_message_model_1.PubSubContactsState.COMPLETE,
+                    integrationName: this.integrationName,
+                }, orderingKey);
+            })
+                .catch(async (error) => {
+                (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not stream contacts`, providerConfig.apiKey, error);
+                this.additionalPubSubContactStreamingClient?.publishMessage({
+                    userId: providerConfig.userId,
+                    timestamp,
+                    contacts: [],
+                    state: pubsub_contacts_message_model_1.PubSubContactsState.FAILED,
+                    integrationName: this.integrationName,
+                }, orderingKey);
+                return this.pubSubContactStreamingClient?.publishMessage({
+                    userId: providerConfig.userId,
+                    timestamp,
+                    contacts: [],
+                    state: pubsub_contacts_message_model_1.PubSubContactsState.FAILED,
+                    integrationName: this.integrationName,
+                }, orderingKey);
+            })
+                .catch((error) => {
+                (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not publish failed message`, providerConfig.apiKey, error);
+            })
+                .finally(() => this.streamingPromises.delete(`${userId}:${timestamp}`));
+            this.streamingPromises.set(`${userId}:${timestamp}`, streamingPromise);
+            if (this.adapter.getToken && req.providerConfig) {
+                try {
+                    const { apiKey } = await this.adapter.getToken(req.providerConfig);
+                    res.header('X-Provider-Key', apiKey);
                 }
-                (0, logger_util_1.infoLogger)(`streamContacts`, `[${orderingKey}] END`, providerConfig.apiKey);
-                res.status(200).send({ timestamp });
-                yield streamingPromise;
-            }
-            catch (error) {
-                // prevent logging of refresh errors
-                if (error instanceof _1.ServerError &&
-                    error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
-                    next(error);
-                    return;
+                catch (error) {
+                    (0, logger_util_1.errorLogger)('streamContacts', `[${orderingKey}] Could not get and refresh token`, providerConfig.apiKey, error);
                 }
-                (0, logger_util_1.errorLogger)('streamContacts', `Could not stream contacts`, providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey, error);
+            }
+            (0, logger_util_1.infoLogger)(`streamContacts`, `[${orderingKey}] END`, providerConfig.apiKey);
+            res.status(200).send({ timestamp });
+            await streamingPromise;
+        }
+        catch (error) {
+            // prevent logging of refresh errors
+            if (error instanceof _1.ServerError &&
+                error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
                 next(error);
+                return;
             }
-        });
+            (0, logger_util_1.errorLogger)('streamContacts', `Could not stream contacts`, providerConfig?.apiKey, error);
+            next(error);
+        }
     }
-    getContact(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig } = req;
-            try {
-                if (!providerConfig) {
-                    throw new _1.ServerError(400, 'Missing parameters');
-                }
-                if (!this.adapter.getContact) {
-                    throw new _1.ServerError(501, 'Getting single contact is not implemented');
-                }
-                (0, logger_util_1.infoLogger)('getContact', 'START', providerConfig.apiKey);
-                const contactType = Object.values(_1.IntegrationEntityType).find((value) => { var _a; return value === ((_a = req.query.type) === null || _a === void 0 ? void 0 : _a.toString()); });
-                if (!contactType) {
-                    throw new _1.ServerError(400, 'Missing contact type query parameter');
-                }
-                const contactId = req.params.id;
-                (0, logger_util_1.infoLogger)('getContact', `Fetching contact ${contactId} of type ${contactType}`, providerConfig.apiKey);
-                const contact = yield this.adapter.getContact(providerConfig, contactId, contactType);
-                (0, logger_util_1.infoLogger)('getContact', 'END', providerConfig.apiKey);
-                res.status(200).send((0, contact_util_1.sanitizeContact)(contact, providerConfig.locale));
-            }
-            catch (error) {
-                // prevent logging of refresh errors
-                if (error instanceof _1.ServerError &&
-                    error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
-                    next(error);
-                    return;
-                }
-                (0, logger_util_1.errorLogger)('getContact', 'Could not get contact:', providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey, error);
+    async getContact(req, res, next) {
+        const { providerConfig } = req;
+        try {
+            if (!providerConfig) {
+                throw new _1.ServerError(400, 'Missing parameters');
+            }
+            if (!this.adapter.getContact) {
+                throw new _1.ServerError(501, 'Getting single contact is not implemented');
+            }
+            (0, logger_util_1.infoLogger)('getContact', 'START', providerConfig.apiKey);
+            const contactType = Object.values(_1.IntegrationEntityType).find((value) => value === req.query.type?.toString());
+            if (!contactType) {
+                throw new _1.ServerError(400, 'Missing contact type query parameter');
+            }
+            const contactId = req.params.id;
+            (0, logger_util_1.infoLogger)('getContact', `Fetching contact ${contactId} of type ${contactType}`, providerConfig.apiKey);
+            const contact = await this.adapter.getContact(providerConfig, contactId, contactType);
+            (0, logger_util_1.infoLogger)('getContact', 'END', providerConfig.apiKey);
+            res.status(200).send((0, contact_util_1.sanitizeContact)(contact, providerConfig.locale));
+        }
+        catch (error) {
+            // prevent logging of refresh errors
+            if (error instanceof _1.ServerError &&
+                error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
                 next(error);
+                return;
             }
-        });
+            (0, logger_util_1.errorLogger)('getContact', 'Could not get contact:', providerConfig?.apiKey, error);
+            next(error);
+        }
     }
-    createContact(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig: { apiKey = '', locale = '' } = {} } = req;
-            try {
-                (0, logger_util_1.infoLogger)('createContact', 'START', apiKey);
-                if (!this.adapter.createContact) {
-                    throw new _1.ServerError(501, 'Creating contacts is not implemented');
-                }
-                if (!req.providerConfig) {
-                    throw new _1.ServerError(400, 'Missing config parameters');
-                }
-                const parseResultContactCreate = schemas_1.contactCreateSchema.safeParse(req.body);
-                if (parseResultContactCreate.error)
-                    throw new _1.ServerError(400, `Invalid contactCreate received: ${parseResultContactCreate.error.message}`);
-                (0, logger_util_1.infoLogger)('createContact', 'Creating contact', apiKey);
-                const contact = yield this.adapter.createContact(req.providerConfig, parseResultContactCreate.data);
-                const parseResultReturnContact = schemas_1.contactSchema.safeParse(contact);
-                if (parseResultReturnContact.error)
-                    throw new _1.ServerError(500, `Invalid contact returned from bridge: ${parseResultReturnContact.error.message}`);
-                (0, logger_util_1.infoLogger)('createContact', `Contact with id ${parseResultReturnContact.data.id} created`, apiKey);
-                const sanitizedContact = (0, contact_util_1.sanitizeContact)(parseResultReturnContact.data, locale);
-                if (this.adapter.getToken && req.providerConfig) {
-                    const { apiKey } = yield this.adapter.getToken(req.providerConfig);
-                    res.header('X-Provider-Key', apiKey);
-                }
-                res.status(200).send(sanitizedContact);
-                if (this.contactCache) {
-                    const contacts = yield this.contactCache.get(apiKey);
-                    if (Array.isArray(contacts)) {
-                        yield this.contactCache.set(apiKey, [...contacts, sanitizedContact]);
-                    }
-                }
-                (0, logger_util_1.infoLogger)('createContact', 'END', apiKey);
-            }
-            catch (error) {
-                // prevent logging of refresh errors
-                if (error instanceof _1.ServerError &&
-                    error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
-                    next(error);
-                    return;
-                }
-                (0, logger_util_1.errorLogger)('createContact', 'Could not create contact:', apiKey, error || 'Unknown');
-                (0, logger_util_1.errorLogger)('createContact', 'Entity', apiKey, req.body);
+    async createContact(req, res, next) {
+        const { providerConfig: { apiKey = '', locale = '' } = {} } = req;
+        try {
+            (0, logger_util_1.infoLogger)('createContact', 'START', apiKey);
+            if (!this.adapter.createContact) {
+                throw new _1.ServerError(501, 'Creating contacts is not implemented');
+            }
+            if (!req.providerConfig) {
+                throw new _1.ServerError(400, 'Missing config parameters');
+            }
+            const parseResultContactCreate = schemas_1.contactCreateSchema.safeParse(req.body);
+            if (parseResultContactCreate.error)
+                throw new _1.ServerError(400, `Invalid contactCreate received: ${parseResultContactCreate.error.message}`);
+            (0, logger_util_1.infoLogger)('createContact', 'Creating contact', apiKey);
+            const contact = await this.adapter.createContact(req.providerConfig, parseResultContactCreate.data);
+            const parseResultReturnContact = schemas_1.contactSchema.safeParse(contact);
+            if (parseResultReturnContact.error)
+                throw new _1.ServerError(500, `Invalid contact returned from bridge: ${parseResultReturnContact.error.message}`);
+            (0, logger_util_1.infoLogger)('createContact', `Contact with id ${parseResultReturnContact.data.id} created`, apiKey);
+            const sanitizedContact = (0, contact_util_1.sanitizeContact)(parseResultReturnContact.data, locale);
+            if (this.adapter.getToken && req.providerConfig) {
+                const { apiKey } = await this.adapter.getToken(req.providerConfig);
+                res.header('X-Provider-Key', apiKey);
+            }
+            res.status(200).send(sanitizedContact);
+            if (this.contactCache) {
+                const contacts = await this.contactCache.get(apiKey);
+                if (Array.isArray(contacts)) {
+                    await this.contactCache.set(apiKey, [...contacts, sanitizedContact]);
+                }
+            }
+            (0, logger_util_1.infoLogger)('createContact', 'END', apiKey);
+        }
+        catch (error) {
+            // prevent logging of refresh errors
+            if (error instanceof _1.ServerError &&
+                error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
                 next(error);
+                return;
             }
-        });
+            (0, logger_util_1.errorLogger)('createContact', 'Could not create contact:', apiKey, error || 'Unknown');
+            (0, logger_util_1.errorLogger)('createContact', 'Entity', apiKey, req.body);
+            next(error);
+        }
     }
-    updateContact(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig: { apiKey = '', locale = '' } = {} } = req;
-            try {
-                if (!this.adapter.updateContact) {
-                    throw new _1.ServerError(501, 'Updating contacts is not implemented');
-                }
-                if (!req.providerConfig) {
-                    throw new _1.ServerError(400, 'Missing config parameters');
-                }
-                const parseResultContactUpdate = schemas_1.contactCreateSchema.safeParse(req.body);
-                if (parseResultContactUpdate.error)
-                    throw new _1.ServerError(400, `Invalid contactUpdate received: ${parseResultContactUpdate.error.message}`);
-                (0, logger_util_1.infoLogger)('updateContact', 'Updating contact', apiKey);
-                const contact = yield this.adapter.updateContact(req.providerConfig, req.params.id, Object.assign(Object.assign({}, parseResultContactUpdate.data), { id: req.params.id }));
-                const parseResultReturnContact = schemas_1.contactSchema.safeParse(contact);
-                if (parseResultReturnContact.error)
-                    throw new _1.ServerError(500, `Invalid contact returned from bridge: ${parseResultReturnContact.error.message}`);
-                (0, logger_util_1.infoLogger)('updateContact', `Contact with id ${parseResultReturnContact.data.id} updated`, apiKey);
-                const sanitizedContact = (0, contact_util_1.sanitizeContact)(parseResultReturnContact.data, locale);
-                if (this.adapter.getToken && req.providerConfig) {
-                    const { apiKey } = yield this.adapter.getToken(req.providerConfig);
-                    res.header('X-Provider-Key', apiKey);
-                }
-                res.status(200).send(sanitizedContact);
-                if (this.contactCache) {
-                    const contacts = yield this.contactCache.get(apiKey);
-                    if (Array.isArray(contacts)) {
-                        const updatedCache = contacts.map((entry) => entry.id === sanitizedContact.id ? sanitizedContact : entry);
-                        yield this.contactCache.set(apiKey, updatedCache);
-                    }
-                }
-                (0, logger_util_1.infoLogger)('updateContact', 'END', apiKey);
-            }
-            catch (error) {
-                // prevent logging of refresh errors
-                if (error instanceof _1.ServerError &&
-                    error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
-                    next(error);
-                    return;
-                }
-                (0, logger_util_1.errorLogger)('updateContact', 'Could not update contact:', apiKey, error || 'Unknown');
-                (0, logger_util_1.errorLogger)('updateContact', 'Entity', apiKey, req.body);
+    async updateContact(req, res, next) {
+        const { providerConfig: { apiKey = '', locale = '' } = {} } = req;
+        try {
+            if (!this.adapter.updateContact) {
+                throw new _1.ServerError(501, 'Updating contacts is not implemented');
+            }
+            if (!req.providerConfig) {
+                throw new _1.ServerError(400, 'Missing config parameters');
+            }
+            const parseResultContactUpdate = schemas_1.contactCreateSchema.safeParse(req.body);
+            if (parseResultContactUpdate.error)
+                throw new _1.ServerError(400, `Invalid contactUpdate received: ${parseResultContactUpdate.error.message}`);
+            (0, logger_util_1.infoLogger)('updateContact', 'Updating contact', apiKey);
+            const contact = await this.adapter.updateContact(req.providerConfig, req.params.id, { ...parseResultContactUpdate.data, id: req.params.id });
+            const parseResultReturnContact = schemas_1.contactSchema.safeParse(contact);
+            if (parseResultReturnContact.error)
+                throw new _1.ServerError(500, `Invalid contact returned from bridge: ${parseResultReturnContact.error.message}`);
+            (0, logger_util_1.infoLogger)('updateContact', `Contact with id ${parseResultReturnContact.data.id} updated`, apiKey);
+            const sanitizedContact = (0, contact_util_1.sanitizeContact)(parseResultReturnContact.data, locale);
+            if (this.adapter.getToken && req.providerConfig) {
+                const { apiKey } = await this.adapter.getToken(req.providerConfig);
+                res.header('X-Provider-Key', apiKey);
+            }
+            res.status(200).send(sanitizedContact);
+            if (this.contactCache) {
+                const contacts = await this.contactCache.get(apiKey);
+                if (Array.isArray(contacts)) {
+                    const updatedCache = contacts.map((entry) => entry.id === sanitizedContact.id ? sanitizedContact : entry);
+                    await this.contactCache.set(apiKey, updatedCache);
+                }
+            }
+            (0, logger_util_1.infoLogger)('updateContact', 'END', apiKey);
+        }
+        catch (error) {
+            // prevent logging of refresh errors
+            if (error instanceof _1.ServerError &&
+                error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
                 next(error);
+                return;
             }
-        });
+            (0, logger_util_1.errorLogger)('updateContact', 'Could not update contact:', apiKey, error || 'Unknown');
+            (0, logger_util_1.errorLogger)('updateContact', 'Entity', apiKey, req.body);
+            next(error);
+        }
     }
-    deleteContact(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig: { apiKey = '' } = {} } = req;
-            try {
-                (0, logger_util_1.infoLogger)('deleteContact', 'START', apiKey);
-                if (!this.adapter.deleteContact) {
-                    throw new _1.ServerError(501, 'Deleting contacts is not implemented');
-                }
-                if (!req.providerConfig) {
-                    throw new _1.ServerError(400, 'Missing config parameters');
-                }
-                (0, logger_util_1.infoLogger)('deleteContact', 'Deleting contact', apiKey);
-                const contactId = req.params.id;
-                yield this.adapter.deleteContact(req.providerConfig, contactId);
-                if (this.adapter.getToken && req.providerConfig) {
-                    const { apiKey } = yield this.adapter.getToken(req.providerConfig);
-                    res.header('X-Provider-Key', apiKey);
-                }
-                res.status(200).send();
-                (0, logger_util_1.infoLogger)('deleteContact', `Contact with id ${contactId} deleted`, apiKey);
-                if (this.contactCache) {
-                    const contacts = yield this.contactCache.get(apiKey);
-                    if (Array.isArray(contacts)) {
-                        const updatedCache = contacts.filter((entry) => entry.id !== contactId);
-                        yield this.contactCache.set(apiKey, updatedCache);
-                    }
-                }
-                (0, logger_util_1.infoLogger)('deleteContact', 'END', apiKey);
-            }
-            catch (error) {
-                // prevent logging of refresh errors
-                if (error instanceof _1.ServerError &&
-                    error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
-                    next(error);
-                    return;
-                }
-                (0, logger_util_1.errorLogger)('deleteContact', 'Could not delete contact:', apiKey, error || 'Unknown');
+    async deleteContact(req, res, next) {
+        const { providerConfig: { apiKey = '' } = {} } = req;
+        try {
+            (0, logger_util_1.infoLogger)('deleteContact', 'START', apiKey);
+            if (!this.adapter.deleteContact) {
+                throw new _1.ServerError(501, 'Deleting contacts is not implemented');
+            }
+            if (!req.providerConfig) {
+                throw new _1.ServerError(400, 'Missing config parameters');
+            }
+            (0, logger_util_1.infoLogger)('deleteContact', 'Deleting contact', apiKey);
+            const contactId = req.params.id;
+            await this.adapter.deleteContact(req.providerConfig, contactId);
+            if (this.adapter.getToken && req.providerConfig) {
+                const { apiKey } = await this.adapter.getToken(req.providerConfig);
+                res.header('X-Provider-Key', apiKey);
+            }
+            res.status(200).send();
+            (0, logger_util_1.infoLogger)('deleteContact', `Contact with id ${contactId} deleted`, apiKey);
+            if (this.contactCache) {
+                const contacts = await this.contactCache.get(apiKey);
+                if (Array.isArray(contacts)) {
+                    const updatedCache = contacts.filter((entry) => entry.id !== contactId);
+                    await this.contactCache.set(apiKey, updatedCache);
+                }
+            }
+            (0, logger_util_1.infoLogger)('deleteContact', 'END', apiKey);
+        }
+        catch (error) {
+            // prevent logging of refresh errors
+            if (error instanceof _1.ServerError &&
+                error.message === integration_error_model_1.IntegrationErrorType.INTEGRATION_REFRESH_ERROR) {
                 next(error);
+                return;
             }
-        });
+            (0, logger_util_1.errorLogger)('deleteContact', 'Could not delete contact:', apiKey, error || 'Unknown');
+            next(error);
+        }
     }
     /**
      * @deprecated Use createOrUpdateCallLogForEntities instead
@@ -456,82 +432,76 @@ class Controller {
      * @param res
      * @param next
      */
-    handleCallEvent(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig } = req;
-            try {
-                (0, logger_util_1.infoLogger)('handleCallEvent', `START`, providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey);
-                if (!providerConfig) {
-                    throw new _1.ServerError(400, 'Missing config parameters');
-                }
-                if (!this.adapter.handleCallEvent) {
-                    throw new _1.ServerError(501, 'Handling call event is not implemented');
-                }
-                if ((0, call_event_util_1.shouldSkipCallEvent)(req.body)) {
-                    (0, logger_util_1.infoLogger)('handleCallEvent', `Skipping call event for call id ${req.body.id}`, providerConfig.apiKey);
-                    res.status(200).send('Skipping call event');
-                    return;
-                }
-                (0, logger_util_1.infoLogger)('handleCallEvent', `Handling call event`, providerConfig.apiKey);
-                const integrationCallEventRef = yield this.adapter.handleCallEvent(providerConfig, req.body);
-                if (integrationCallEventRef != '')
-                    (0, logger_util_1.infoLogger)('handleCallEvent', `CallEvent with refId ${integrationCallEventRef} created!`, providerConfig.apiKey);
-                else
-                    (0, logger_util_1.infoLogger)('handleCallEvent', `Did not create callEvent`, providerConfig.apiKey);
-                (0, logger_util_1.infoLogger)('handleCallEvent', `END`, providerConfig.apiKey);
-                res.status(200).send(integrationCallEventRef);
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('handleCallEvent', 'Could not handle call event:', providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey, [error || 'Unknown', req.body]);
-                next(error);
+    async handleCallEvent(req, res, next) {
+        const { providerConfig } = req;
+        try {
+            (0, logger_util_1.infoLogger)('handleCallEvent', `START`, providerConfig?.apiKey);
+            if (!providerConfig) {
+                throw new _1.ServerError(400, 'Missing config parameters');
             }
-        });
-    }
-    handleConnectedEvent(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig: { apiKey = '' } = {} } = req;
-            try {
-                (0, logger_util_1.infoLogger)('handleConnectedEvent', `START`, apiKey);
-                if (!this.adapter.handleConnectedEvent) {
-                    throw new _1.ServerError(501, 'Handling connected event is not implemented');
-                }
-                if (!req.providerConfig) {
-                    throw new _1.ServerError(400, 'Missing config parameters');
-                }
-                (0, logger_util_1.infoLogger)('handleConnectedEvent', `Handling connected event`, apiKey);
-                yield this.adapter.handleConnectedEvent(req.providerConfig);
-                (0, logger_util_1.infoLogger)('handleConnectedEvent', `END`, apiKey);
-                res.status(200).send();
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('handleConnectedEvent', `Could not handle connected event:`, apiKey, error || 'Unknown');
-                (0, logger_util_1.errorLogger)('handleConnectedEvent', 'Entity', apiKey, req.body);
-                next(error);
+            if (!this.adapter.handleCallEvent) {
+                throw new _1.ServerError(501, 'Handling call event is not implemented');
             }
-        });
-    }
-    handleDisconnectedEvent(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig: { apiKey = '' } = {} } = req;
-            try {
-                (0, logger_util_1.infoLogger)('handleDisconnectedEvent', `START`, apiKey);
-                if (!this.adapter.handleDisconnectedEvent) {
-                    throw new _1.ServerError(501, 'Handling disconnected event is not implemented');
-                }
-                if (!req.providerConfig) {
-                    throw new _1.ServerError(400, 'Missing config parameters');
-                }
-                (0, logger_util_1.infoLogger)('handleDisconnectedEvent', `Handling disconnected event`, apiKey);
-                yield this.adapter.handleDisconnectedEvent(req.providerConfig);
-                (0, logger_util_1.infoLogger)('handleDisconnectedEvent', `END`, apiKey);
-                res.status(200).send();
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('handleDisconnectedEvent', `Could not handle connected event:`, apiKey, error || 'Unknown');
-                (0, logger_util_1.errorLogger)('handleDisconnectedEvent', 'Entity', apiKey, req.body);
-                next(error);
+            if ((0, call_event_util_1.shouldSkipCallEvent)(req.body)) {
+                (0, logger_util_1.infoLogger)('handleCallEvent', `Skipping call event for call id ${req.body.id}`, providerConfig.apiKey);
+                res.status(200).send('Skipping call event');
+                return;
             }
-        });
+            (0, logger_util_1.infoLogger)('handleCallEvent', `Handling call event`, providerConfig.apiKey);
+            const integrationCallEventRef = await this.adapter.handleCallEvent(providerConfig, req.body);
+            if (integrationCallEventRef != '')
+                (0, logger_util_1.infoLogger)('handleCallEvent', `CallEvent with refId ${integrationCallEventRef} created!`, providerConfig.apiKey);
+            else
+                (0, logger_util_1.infoLogger)('handleCallEvent', `Did not create callEvent`, providerConfig.apiKey);
+            (0, logger_util_1.infoLogger)('handleCallEvent', `END`, providerConfig.apiKey);
+            res.status(200).send(integrationCallEventRef);
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('handleCallEvent', 'Could not handle call event:', providerConfig?.apiKey, [error || 'Unknown', req.body]);
+            next(error);
+        }
+    }
+    async handleConnectedEvent(req, res, next) {
+        const { providerConfig: { apiKey = '' } = {} } = req;
+        try {
+            (0, logger_util_1.infoLogger)('handleConnectedEvent', `START`, apiKey);
+            if (!this.adapter.handleConnectedEvent) {
+                throw new _1.ServerError(501, 'Handling connected event is not implemented');
+            }
+            if (!req.providerConfig) {
+                throw new _1.ServerError(400, 'Missing config parameters');
+            }
+            (0, logger_util_1.infoLogger)('handleConnectedEvent', `Handling connected event`, apiKey);
+            await this.adapter.handleConnectedEvent(req.providerConfig);
+            (0, logger_util_1.infoLogger)('handleConnectedEvent', `END`, apiKey);
+            res.status(200).send();
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('handleConnectedEvent', `Could not handle connected event:`, apiKey, error || 'Unknown');
+            (0, logger_util_1.errorLogger)('handleConnectedEvent', 'Entity', apiKey, req.body);
+            next(error);
+        }
+    }
+    async handleDisconnectedEvent(req, res, next) {
+        const { providerConfig: { apiKey = '' } = {} } = req;
+        try {
+            (0, logger_util_1.infoLogger)('handleDisconnectedEvent', `START`, apiKey);
+            if (!this.adapter.handleDisconnectedEvent) {
+                throw new _1.ServerError(501, 'Handling disconnected event is not implemented');
+            }
+            if (!req.providerConfig) {
+                throw new _1.ServerError(400, 'Missing config parameters');
+            }
+            (0, logger_util_1.infoLogger)('handleDisconnectedEvent', `Handling disconnected event`, apiKey);
+            await this.adapter.handleDisconnectedEvent(req.providerConfig);
+            (0, logger_util_1.infoLogger)('handleDisconnectedEvent', `END`, apiKey);
+            res.status(200).send();
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('handleDisconnectedEvent', `Could not handle connected event:`, apiKey, error || 'Unknown');
+            (0, logger_util_1.errorLogger)('handleDisconnectedEvent', 'Entity', apiKey, req.body);
+            next(error);
+        }
     }
     /**
      * @deprecated Use createOrUpdateCallLogForEntities instead
@@ -539,207 +509,194 @@ class Controller {
      * @param res
      * @param next
      */
-    updateCallEvent(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig: { apiKey = '' } = {}, body, params } = req;
-            try {
-                (0, logger_util_1.infoLogger)('updateCallEvent', `START`, apiKey);
-                if (!this.adapter.updateCallEvent) {
-                    throw new _1.ServerError(501, 'Updating call events is not implemented');
-                }
-                if (!req.providerConfig) {
-                    throw new _1.ServerError(400, 'Missing config parameters');
-                }
-                (0, logger_util_1.infoLogger)('updateCallEvent', `Updating call event`, apiKey);
-                yield this.adapter.updateCallEvent(req.providerConfig, params.id, body);
-                (0, logger_util_1.infoLogger)('updateCallEvent', `END`, apiKey);
-                res.status(200).send();
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('updateCallEvent', `Could not update call event:`, apiKey, error || 'Unknown');
-                (0, logger_util_1.errorLogger)('updateCallEvent', 'Entity', apiKey, req.body);
-                next(error);
-            }
-        });
+    async updateCallEvent(req, res, next) {
+        const { providerConfig: { apiKey = '' } = {}, body, params } = req;
+        try {
+            (0, logger_util_1.infoLogger)('updateCallEvent', `START`, apiKey);
+            if (!this.adapter.updateCallEvent) {
+                throw new _1.ServerError(501, 'Updating call events is not implemented');
+            }
+            if (!req.providerConfig) {
+                throw new _1.ServerError(400, 'Missing config parameters');
+            }
+            (0, logger_util_1.infoLogger)('updateCallEvent', `Updating call event`, apiKey);
+            await this.adapter.updateCallEvent(req.providerConfig, params.id, body);
+            (0, logger_util_1.infoLogger)('updateCallEvent', `END`, apiKey);
+            res.status(200).send();
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('updateCallEvent', `Could not update call event:`, apiKey, error || 'Unknown');
+            (0, logger_util_1.errorLogger)('updateCallEvent', 'Entity', apiKey, req.body);
+            next(error);
+        }
     }
-    getEntity(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig } = req;
-            try {
-                (0, logger_util_1.infoLogger)('getEntity', `START`, providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey);
-                if (!providerConfig) {
-                    throw new _1.ServerError(400, 'Missing parameters');
-                }
-                if (!this.adapter.getEntity) {
-                    throw new _1.ServerError(501, 'Fetching Entity is not implemented');
-                }
-                const fetchedEntity = yield this.adapter.getEntity(providerConfig, req.params.id, req.params.type);
-                (0, logger_util_1.infoLogger)('getEntity', `successfully got entity`, providerConfig.apiKey, Object.assign(Object.assign({}, fetchedEntity), { label: (0, anonymize_key_1.anonymizeKey)(fetchedEntity === null || fetchedEntity === void 0 ? void 0 : fetchedEntity.label) }));
-                (0, logger_util_1.infoLogger)('getEntity', `END`, providerConfig.apiKey);
-                res.status(200).send(fetchedEntity);
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('getEntity', 'Could not get entity:', providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey, error);
-                next(error);
+    async getEntity(req, res, next) {
+        const { providerConfig } = req;
+        try {
+            (0, logger_util_1.infoLogger)('getEntity', `START`, providerConfig?.apiKey);
+            if (!providerConfig) {
+                throw new _1.ServerError(400, 'Missing parameters');
             }
-        });
-    }
-    getEntitiesForContact(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig } = req;
-            try {
-                (0, logger_util_1.infoLogger)('getEntitiesForContact', `START`, providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey);
-                if (!providerConfig) {
-                    throw new _1.ServerError(400, 'Missing parameters');
-                }
-                if (!this.adapter.getEntitiesForContact) {
-                    throw new _1.ServerError(501, 'Fetching Entities for contact is not implemented');
-                }
-                const fetchedEntities = yield this.adapter.getEntitiesForContact(providerConfig, req.params.id);
-                (0, logger_util_1.infoLogger)('getEntitiesForContact', `successfully fetched ${fetchedEntities.length} entities`, providerConfig.apiKey, {
-                    count: fetchedEntities.length,
-                });
-                (0, logger_util_1.infoLogger)('getEntitiesForContact', `END`, providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey);
-                res.status(200).send(fetchedEntities);
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('getEntitiesForContact', 'Could not get entities for contact', providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey, error);
-                next(error);
+            if (!this.adapter.getEntity) {
+                throw new _1.ServerError(501, 'Fetching Entity is not implemented');
             }
-        });
+            const fetchedEntity = await this.adapter.getEntity(providerConfig, req.params.id, req.params.type);
+            (0, logger_util_1.infoLogger)('getEntity', `successfully got entity`, providerConfig.apiKey, {
+                ...fetchedEntity,
+                label: (0, anonymize_key_1.anonymizeKey)(fetchedEntity?.label),
+            });
+            (0, logger_util_1.infoLogger)('getEntity', `END`, providerConfig.apiKey);
+            res.status(200).send(fetchedEntity);
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('getEntity', 'Could not get entity:', providerConfig?.apiKey, error);
+            next(error);
+        }
     }
-    getHealth(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (this.adapter.getHealth) {
-                    yield this.adapter.getHealth();
-                }
-                res.sendStatus(200);
+    async getEntitiesForContact(req, res, next) {
+        const { providerConfig } = req;
+        try {
+            (0, logger_util_1.infoLogger)('getEntitiesForContact', `START`, providerConfig?.apiKey);
+            if (!providerConfig) {
+                throw new _1.ServerError(400, 'Missing parameters');
             }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('getHealth', 'Health check failed:', '', error || 'Unknown');
-                next(error || 'Internal Server Error');
+            if (!this.adapter.getEntitiesForContact) {
+                throw new _1.ServerError(501, 'Fetching Entities for contact is not implemented');
             }
-        });
+            const fetchedEntities = await this.adapter.getEntitiesForContact(providerConfig, req.params.id);
+            (0, logger_util_1.infoLogger)('getEntitiesForContact', `successfully fetched ${fetchedEntities.length} entities`, providerConfig.apiKey, {
+                count: fetchedEntities.length,
+            });
+            (0, logger_util_1.infoLogger)('getEntitiesForContact', `END`, providerConfig?.apiKey);
+            res.status(200).send(fetchedEntities);
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('getEntitiesForContact', 'Could not get entities for contact', providerConfig?.apiKey, error);
+            next(error);
+        }
     }
-    oAuth2Redirect(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.adapter.getOAuth2RedirectUrl) {
-                    throw new _1.ServerError(501, 'OAuth2 flow not implemented');
-                }
-                const redirectUrl = yield this.adapter.getOAuth2RedirectUrl(req, res);
-                res.status(200).send({ redirectUrl });
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('oAuth2Redirect', 'Could not get OAuth2 redirect URL:', '', error || 'Unknown');
-                next(error);
+    async getHealth(req, res, next) {
+        try {
+            if (this.adapter.getHealth) {
+                await this.adapter.getHealth();
             }
-        });
+            res.sendStatus(200);
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('getHealth', 'Health check failed:', '', error || 'Unknown');
+            next(error || 'Internal Server Error');
+        }
     }
-    oAuth2Callback(req, res) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { OAUTH2_REDIRECT_URL: redirectUrl, OAUTH2_IDENTIFIER: oAuth2Identifier = 'UNKNOWN', } = process.env;
-            if (!redirectUrl) {
-                (0, logger_util_1.errorLogger)('oAuth2Callback', 'OAuth2 Redirect URL not configured!', '');
-                res.status(500).send('OAuth2 Redirect URL not configured!');
-                return;
+    async oAuth2Redirect(req, res, next) {
+        try {
+            if (!this.adapter.getOAuth2RedirectUrl) {
+                throw new _1.ServerError(501, 'OAuth2 flow not implemented');
             }
-            try {
-                if (!this.adapter.handleOAuth2Callback) {
-                    throw new _1.ServerError(501, 'OAuth2 flow not implemented');
-                }
-                const { apiKey, apiUrl } = yield this.adapter.handleOAuth2Callback(req, res);
-                const params = (0, querystring_1.stringify)({
-                    name: oAuth2Identifier,
-                    key: apiKey,
-                    url: apiUrl,
-                });
-                res.redirect(`${redirectUrl}?${params}`);
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('oAuth2Callback', 'Unable to save OAuth2 token:', '', error || 'Unknown');
-                res.redirect(redirectUrl);
-            }
-        });
+            const redirectUrl = await this.adapter.getOAuth2RedirectUrl(req, res);
+            res.status(200).send({ redirectUrl });
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('oAuth2Redirect', 'Could not get OAuth2 redirect URL:', '', error || 'Unknown');
+            next(error);
+        }
     }
-    oAuth2Token(req, res) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.adapter.handleOAuth2Callback) {
-                    throw new _1.ServerError(501, 'OAuth2 flow not implemented');
-                }
-                const credentials = yield this.adapter.handleOAuth2Callback(req, res);
-                res.json(credentials);
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('oAuth2Callback', 'Unable to save OAuth2 token:', '', error || 'Unknown');
-                throw error;
-            }
-        });
+    async oAuth2Callback(req, res) {
+        const { OAUTH2_REDIRECT_URL: redirectUrl, OAUTH2_IDENTIFIER: oAuth2Identifier = 'UNKNOWN', } = process.env;
+        if (!redirectUrl) {
+            (0, logger_util_1.errorLogger)('oAuth2Callback', 'OAuth2 Redirect URL not configured!', '');
+            res.status(500).send('OAuth2 Redirect URL not configured!');
+            return;
+        }
+        try {
+            if (!this.adapter.handleOAuth2Callback) {
+                throw new _1.ServerError(501, 'OAuth2 flow not implemented');
+            }
+            const { apiKey, apiUrl } = await this.adapter.handleOAuth2Callback(req, res);
+            const params = (0, querystring_1.stringify)({
+                name: oAuth2Identifier,
+                key: apiKey,
+                url: apiUrl,
+            });
+            res.redirect(`${redirectUrl}?${params}`);
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('oAuth2Callback', 'Unable to save OAuth2 token:', '', error || 'Unknown');
+            res.redirect(redirectUrl);
+        }
     }
-    getAccountId(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig } = req;
-            try {
-                if (!providerConfig) {
-                    throw new _1.ServerError(400, 'Missing parameters');
-                }
-                if (!this.adapter.getAccountId) {
-                    throw new _1.ServerError(501, 'Fetching account id is not implemented');
-                }
-                (0, logger_util_1.infoLogger)('getAccountId', 'START', providerConfig.apiKey);
-                const accountId = yield this.adapter.getAccountId(providerConfig);
-                if (!accountId) {
-                    throw new _1.ServerError(500, 'AccountID not found');
-                }
-                (0, logger_util_1.infoLogger)('getAccountId', 'END', providerConfig.apiKey);
-                res.status(200).json(accountId.toString());
-            }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('getAccountId', 'Could not get AccountId', providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.apiKey, error);
-                next(error);
+    async oAuth2Token(req, res) {
+        try {
+            if (!this.adapter.handleOAuth2Callback) {
+                throw new _1.ServerError(501, 'OAuth2 flow not implemented');
             }
-        });
+            const credentials = await this.adapter.handleOAuth2Callback(req, res);
+            res.json(credentials);
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('oAuth2Callback', 'Unable to save OAuth2 token:', '', error || 'Unknown');
+            throw error;
+        }
     }
-    handleWebhook(req, res, next) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this.adapter.handleWebhook) {
-                    throw new _1.ServerError(501, 'Webhook handling not implemented');
-                }
-                if (!this.adapter.verifyWebhookRequest) {
-                    throw new _1.ServerError(501, 'Webhook verification not implemented');
-                }
-                const verified = yield this.adapter.verifyWebhookRequest(req);
-                if (!verified) {
-                    (0, logger_util_1.errorLogger)('handleWebhook', 'Webhook verification failed');
-                    throw new _1.ServerError(403, 'Webhook verification failed');
-                }
-                (0, logger_util_1.infoLogger)('handleWebhook', 'START');
-                const events = yield this.adapter.handleWebhook(req);
-                (0, logger_util_1.infoLogger)('handleWebhook', `Got ${events.length} events`);
-                const deduplicatedEvents = (0, lodash_1.uniqWith)(events, lodash_1.isEqual);
-                const publishResults = yield Promise.allSettled(deduplicatedEvents
-                    .map((event) => (Object.assign({ integrationName: this.integrationName }, event)))
-                    .map((message) => {
-                    var _a;
-                    (0, logger_util_1.infoLogger)('handleWebhook', `Publishing event ${message.type} with accountId ${message.accountId}`);
-                    return (_a = this.pubSubIntegrationEventsClient) === null || _a === void 0 ? void 0 : _a.publishMessage(message);
-                }));
-                publishResults.forEach((result) => {
-                    if (result.status === 'rejected') {
-                        (0, logger_util_1.errorLogger)('handleWebhook', `Could not publish event ${result.reason.type} with accountId ${result.reason.accountId}`, '', result.reason);
-                    }
-                });
-                (0, logger_util_1.infoLogger)('handleWebhook', 'END', '');
-                res.sendStatus(200);
+    async getAccountId(req, res, next) {
+        const { providerConfig } = req;
+        try {
+            if (!providerConfig) {
+                throw new _1.ServerError(400, 'Missing parameters');
             }
-            catch (error) {
-                (0, logger_util_1.errorLogger)('handleWebhook', 'Could not handle webhook:', '', error || 'Unknown');
-                next(error);
+            if (!this.adapter.getAccountId) {
+                throw new _1.ServerError(501, 'Fetching account id is not implemented');
+            }
+            (0, logger_util_1.infoLogger)('getAccountId', 'START', providerConfig.apiKey);
+            const accountId = await this.adapter.getAccountId(providerConfig);
+            if (!accountId) {
+                throw new _1.ServerError(500, 'AccountID not found');
             }
-        });
+            (0, logger_util_1.infoLogger)('getAccountId', 'END', providerConfig.apiKey);
+            res.status(200).json(accountId.toString());
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('getAccountId', 'Could not get AccountId', providerConfig?.apiKey, error);
+            next(error);
+        }
+    }
+    async handleWebhook(req, res, next) {
+        try {
+            if (!this.adapter.handleWebhook) {
+                throw new _1.ServerError(501, 'Webhook handling not implemented');
+            }
+            if (!this.adapter.verifyWebhookRequest) {
+                throw new _1.ServerError(501, 'Webhook verification not implemented');
+            }
+            const verified = await this.adapter.verifyWebhookRequest(req);
+            if (!verified) {
+                (0, logger_util_1.errorLogger)('handleWebhook', 'Webhook verification failed');
+                throw new _1.ServerError(403, 'Webhook verification failed');
+            }
+            (0, logger_util_1.infoLogger)('handleWebhook', 'START');
+            const events = await this.adapter.handleWebhook(req);
+            (0, logger_util_1.infoLogger)('handleWebhook', `Got ${events.length} events`);
+            const deduplicatedEvents = (0, lodash_1.uniqWith)(events, lodash_1.isEqual);
+            const publishResults = await Promise.allSettled(deduplicatedEvents
+                .map((event) => ({
+                integrationName: this.integrationName,
+                ...event,
+            }))
+                .map((message) => {
+                (0, logger_util_1.infoLogger)('handleWebhook', `Publishing event ${message.type} with accountId ${message.accountId}`);
+                return this.pubSubIntegrationEventsClient?.publishMessage(message);
+            }));
+            publishResults.forEach((result) => {
+                if (result.status === 'rejected') {
+                    (0, logger_util_1.errorLogger)('handleWebhook', `Could not publish event ${result.reason.type} with accountId ${result.reason.accountId}`, '', result.reason);
+                }
+            });
+            (0, logger_util_1.infoLogger)('handleWebhook', 'END', '');
+            res.sendStatus(200);
+        }
+        catch (error) {
+            (0, logger_util_1.errorLogger)('handleWebhook', 'Could not handle webhook:', '', error || 'Unknown');
+            next(error);
+        }
     }
 }
 exports.Controller = Controller;