@app-connect/core 1.7.36 → 1.7.38

package/{lib → dist/lib}/oauth.js

@@ -1,160 +1,157 @@
-/* eslint-disable no-param-reassign */
-const ClientOAuth2 = require('client-oauth2');
-const moment = require('moment');
-const { UserModel } = require('../models/userModel');
-const connectorRegistry = require('../connector/registry');
-const logger = require('./logger');
-const { handleDatabaseError } = require('./errorHandler');
-// oauthApp strategy is default to 'code' which use credentials to get accessCode, then exchange for accessToken and refreshToken.
-// To change to other strategies, please refer to: https://github.com/mulesoft-labs/js-client-oauth2
-function getOAuthApp({ clientId, clientSecret, accessTokenUri, authorizationUri, redirectUri, scopes }) {
-    return new ClientOAuth2({
-        clientId: clientId,
-        clientSecret: clientSecret,
-        accessTokenUri: accessTokenUri,
-        authorizationUri: authorizationUri,
-        redirectUri: redirectUri,
-        scopes: scopes
-    });
-}
-
-
-async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20) {
-    const now = moment();
-    const tokenExpiry = moment(user.tokenExpiry);
-    const expiryBuffer = 2; // 2 minutes
-    // Special case: Bullhorn
-    if (user.platform) {
-        const platformModule = connectorRegistry.getConnector(user.platform);
-        if (platformModule.checkAndRefreshAccessToken) {
-            return platformModule.checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout);
-        }
-    }
-    // Other CRMs - check if token will expire within the buffer time
-    if (user && user.accessToken && user.refreshToken && tokenExpiry.isBefore(now.clone().add(expiryBuffer, 'minutes'))) {
-        // case: use dynamoDB to manage token refresh lock
-        if (process.env.USE_TOKEN_REFRESH_LOCK_PLATFORMS?.split(',')?.includes(user.platform)) {
-            let newLock;
-            const { Lock } = require('../models/dynamo/lockSchema');
-            // Try to atomically create lock only if it doesn't exist
-            try {
-                newLock = await Lock.create(
-                    {
-                        userId: user.id,
-                        ttl: now.unix() + tokenLockTimeout
-                    },
-                    {
-                        overwrite: false
-                    }
-                );
-                logger.info('lock created')
-            } catch (e) {
-                // If creation failed due to condition, a lock exists
-                if (e.name === 'ConditionalCheckFailedException' || e.__type === 'com.amazonaws.dynamodb.v20120810#ConditionalCheckFailedException') {
-                    let lock = await Lock.get({ userId: user.id });
-                    if (!!lock?.ttl && moment(lock.ttl).unix() < now.unix()) {
-                        // Try to delete expired lock and create a new one atomically
-                        try {
-                            logger.info('lock expired.')
-                            await lock.delete();
-                            newLock = await Lock.create(
-                                {
-                                    userId: user.id,
-                                    ttl: now.unix() + tokenLockTimeout
-                                },
-                                {
-                                    overwrite: false
-                                }
-                            );
-                        } catch (e2) {
-                            if (e2.name === 'ConditionalCheckFailedException' || e2.__type === 'com.amazonaws.dynamodb.v20120810#ConditionalCheckFailedException') {
-                                // Another process created a lock between our delete and create
-                                lock = await Lock.get({ userId: user.id });
-                            } else {
-                                throw e2;
-                            }
-                        }
-                    }
-
-                    if (lock && !newLock) {
-                        let processTime = 0;
-                        let delay = 500; // Start with 500ms
-                        const maxDelay = 8000; // Cap at 8 seconds
-                        while (!!lock && processTime < tokenLockTimeout) {
-                            await new Promise(resolve => setTimeout(resolve, delay));
-                            processTime += delay / 1000; // Convert to seconds for comparison
-                            delay = Math.min(delay * 2, maxDelay); // Exponential backoff with cap
-                            lock = await Lock.get({ userId: user.id });
-                        }
-                        // Timeout -> let users try another time
-                        if (processTime >= tokenLockTimeout) {
-                            throw new Error('Token lock timeout');
-                        }
-                        user = await UserModel.findByPk(user.id);
-                        logger.info('locked. bypass')
-                        return user;
-                    }
-                } else {
-                    throw e;
-                }
-            }
-            try {
-                const startRefreshTime = moment();
-                const token = oauthApp.createToken(user.accessToken, user.refreshToken);
-                logger.info('token refreshing...')
-                const { accessToken, refreshToken, expires } = await token.refresh();
-                user.accessToken = accessToken;
-                user.refreshToken = refreshToken;
-                user.tokenExpiry = expires;
-                try {
-                    await user.save();
-                }
-                catch (error) {
-                    return handleDatabaseError(error, 'Error saving user');
-                }
-                if (newLock) {
-                    const deletionStartTime = moment();
-                    await newLock.delete();
-                    const deletionEndTime = moment();
-                    logger.info(`lock deleted in ${deletionEndTime.diff(deletionStartTime)}ms`)
-                }
-                const endRefreshTime = moment();
-                logger.info(`token refreshing finished in ${endRefreshTime.diff(startRefreshTime)}ms`)
-            }
-            catch (e) {
-                console.log('token refreshing failed', e.stack)
-                if (newLock) {
-                    await newLock.delete();
-                }
-                return null;
-            }
-        }
-        // case: run withou token refresh lock
-        else {
-            try {
-                logger.info('token refreshing...')
-                const token = oauthApp.createToken(user.accessToken, user.refreshToken);
-                const { accessToken, refreshToken, expires } = await token.refresh();
-                user.accessToken = accessToken;
-                user.refreshToken = refreshToken;
-                user.tokenExpiry = expires;
-            }
-            catch (e) {
-                console.log('token refreshing failed', e.stack)
-                return null;
-            }
-            try {
-                await user.save();
-            }
-            catch (error) {
-                return handleDatabaseError(error, 'Error saving user');
-            }
-            logger.info('token refreshing finished')
-        }
-
-    }
-    return user;
-}
-
-exports.checkAndRefreshAccessToken = checkAndRefreshAccessToken;
-exports.getOAuthApp = getOAuthApp;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAndRefreshAccessToken = checkAndRefreshAccessToken;
+exports.getOAuthApp = getOAuthApp;
+const ClientOAuth2 = require('client-oauth2');
+const moment = require('moment');
+const { UserModel: UserModelImport } = require('../models/userModel');
+const UserModel = UserModelImport;
+const connectorRegistry = require('../connector/registry');
+const logger = require('./logger');
+const { handleDatabaseError } = require('./errorHandler');
+// oauthApp strategy is default to 'code' which use credentials to get accessCode, then exchange for accessToken and refreshToken.
+// To change to other strategies, please refer to: https://github.com/mulesoft-labs/js-client-oauth2
+function getOAuthApp({ clientId, clientSecret, accessTokenUri, authorizationUri, redirectUri, scopes }) {
+    return new ClientOAuth2({
+        clientId: clientId,
+        clientSecret: clientSecret,
+        accessTokenUri: accessTokenUri,
+        authorizationUri: authorizationUri,
+        redirectUri: redirectUri,
+        scopes: scopes
+    });
+}
+async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20) {
+    const now = moment();
+    const tokenExpiry = moment(user.tokenExpiry);
+    const expiryBuffer = 2; // 2 minutes
+    // Special case: Bullhorn
+    if (user.platform) {
+        const platformModule = connectorRegistry.getConnector(user.platform);
+        if (platformModule.checkAndRefreshAccessToken) {
+            return platformModule.checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout);
+        }
+    }
+    // Other CRMs - check if token will expire within the buffer time
+    if (user && user.accessToken && user.refreshToken && tokenExpiry.isBefore(now.clone().add(expiryBuffer, 'minutes'))) {
+        // case: use dynamoDB to manage token refresh lock
+        if (process.env.USE_TOKEN_REFRESH_LOCK_PLATFORMS?.split(',')?.includes(user.platform)) {
+            let newLock;
+            const { Lock } = require('../models/dynamo/lockSchema');
+            // Try to atomically create lock only if it doesn't exist
+            try {
+                newLock = await Lock.create({
+                    userId: user.id,
+                    ttl: now.unix() + tokenLockTimeout
+                }, {
+                    overwrite: false
+                });
+                logger.info('lock created');
+            }
+            catch (e) {
+                const lockError = e;
+                // If creation failed due to condition, a lock exists
+                if (lockError.name === 'ConditionalCheckFailedException' || lockError.__type === 'com.amazonaws.dynamodb.v20120810#ConditionalCheckFailedException') {
+                    let lock = await Lock.get({ userId: user.id });
+                    if (!!lock?.ttl && moment(lock.ttl).unix() < now.unix()) {
+                        // Try to delete expired lock and create a new one atomically
+                        try {
+                            logger.info('lock expired.');
+                            await lock.delete();
+                            newLock = await Lock.create({
+                                userId: user.id,
+                                ttl: now.unix() + tokenLockTimeout
+                            }, {
+                                overwrite: false
+                            });
+                        }
+                        catch (e2) {
+                            const expiredLockError = e2;
+                            if (expiredLockError.name === 'ConditionalCheckFailedException' || expiredLockError.__type === 'com.amazonaws.dynamodb.v20120810#ConditionalCheckFailedException') {
+                                // Another process created a lock between our delete and create
+                                lock = await Lock.get({ userId: user.id });
+                            }
+                            else {
+                                throw e2;
+                            }
+                        }
+                    }
+                    if (lock && !newLock) {
+                        let processTime = 0;
+                        let delay = 500; // Start with 500ms
+                        const maxDelay = 8000; // Cap at 8 seconds
+                        while (!!lock && processTime < tokenLockTimeout) {
+                            await new Promise(resolve => setTimeout(resolve, delay));
+                            processTime += delay / 1000; // Convert to seconds for comparison
+                            delay = Math.min(delay * 2, maxDelay); // Exponential backoff with cap
+                            lock = await Lock.get({ userId: user.id });
+                        }
+                        // Timeout -> let users try another time
+                        if (processTime >= tokenLockTimeout) {
+                            throw new Error('Token lock timeout');
+                        }
+                        user = await UserModel.findByPk(user.id);
+                        logger.info('locked. bypass');
+                        return user;
+                    }
+                }
+                else {
+                    throw e;
+                }
+            }
+            try {
+                const startRefreshTime = moment();
+                const token = oauthApp.createToken(user.accessToken, user.refreshToken);
+                logger.info('token refreshing...');
+                const { accessToken, refreshToken, expires } = await token.refresh();
+                user.accessToken = accessToken;
+                user.refreshToken = refreshToken;
+                user.tokenExpiry = expires;
+                try {
+                    await user.save();
+                }
+                catch (error) {
+                    return handleDatabaseError(error, 'Error saving user');
+                }
+                if (newLock) {
+                    const deletionStartTime = moment();
+                    await newLock.delete();
+                    const deletionEndTime = moment();
+                    logger.info(`lock deleted in ${deletionEndTime.diff(deletionStartTime)}ms`);
+                }
+                const endRefreshTime = moment();
+                logger.info(`token refreshing finished in ${endRefreshTime.diff(startRefreshTime)}ms`);
+            }
+            catch (e) {
+                console.log('token refreshing failed', e.stack);
+                if (newLock) {
+                    await newLock.delete();
+                }
+                return null;
+            }
+        }
+        // case: run withou token refresh lock
+        else {
+            try {
+                logger.info('token refreshing...');
+                const token = oauthApp.createToken(user.accessToken, user.refreshToken);
+                const { accessToken, refreshToken, expires } = await token.refresh();
+                user.accessToken = accessToken;
+                user.refreshToken = refreshToken;
+                user.tokenExpiry = expires;
+            }
+            catch (e) {
+                console.log('token refreshing failed', e.stack);
+                return null;
+            }
+            try {
+                await user.save();
+            }
+            catch (error) {
+                return handleDatabaseError(error, 'Error saving user');
+            }
+            logger.info('token refreshing finished');
+        }
+    }
+    return user;
+}

package/dist/lib/ringcentral.d.ts

@@ -0,0 +1,24 @@
+import type { RingCentralCallsAggregationParams, RingCentralFetchResponse, RingCentralGenerateTokenParams, RingCentralLoginUrlParams, RingCentralOptions, RingCentralPaginatedDataParams, RingCentralRequestOptions, RingCentralSubscriptionParams, RingCentralToken } from '../types';
+declare function isRefreshTokenValid(token: RingCentralToken, handicap?: number): boolean;
+declare function isAccessTokenValid(token: RingCentralToken, handicap?: number): boolean;
+declare class RingCentral {
+    _options: RingCentralOptions;
+    constructor(options: RingCentralOptions);
+    loginUrl({ state }: RingCentralLoginUrlParams): string;
+    generateToken({ code }: RingCentralGenerateTokenParams): Promise<RingCentralToken>;
+    refreshToken(token: RingCentralToken): Promise<RingCentralToken>;
+    revokeToken(token: RingCentralToken): Promise<void>;
+    _tokenRequest(path: string, body: Record<string, any>): Promise<RingCentralFetchResponse>;
+    request({ server, path, query, body, method, accept }: RingCentralRequestOptions, token: RingCentralToken): Promise<RingCentralFetchResponse>;
+    createSubscription({ eventFilters, webhookUri }: RingCentralSubscriptionParams, token: RingCentralToken): Promise<any>;
+    getExtensionInfo(extensionId: string | number, token: RingCentralToken): Promise<any>;
+    getAccountInfo(token: RingCentralToken): Promise<any>;
+    getCallsAggregationData({ token, timezone, timeFrom, timeTo, groupBy }: RingCentralCallsAggregationParams): Promise<any>;
+    getCallLogData({ extensionId, token, timeFrom, timeTo }: RingCentralPaginatedDataParams): Promise<{
+        records: any[];
+    }>;
+    getSMSData({ extensionId, token, timeFrom, timeTo }: RingCentralPaginatedDataParams): Promise<{
+        records: any[];
+    }>;
+}
+export { RingCentral, isRefreshTokenValid, isAccessTokenValid };

package/dist/lib/ringcentral.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RingCentral = void 0;
+exports.isRefreshTokenValid = isRefreshTokenValid;
+exports.isAccessTokenValid = isAccessTokenValid;
+const fetch = require('node-fetch');
+const DEFAULT_RENEW_HANDICAP_MS = 60 * 1000;
+const REFRESH_RENEW_HANDICAP_MS = 10 * 1000;
+function stringifyQuery(query) {
+    const queryParams = new URLSearchParams(query);
+    return queryParams.toString();
+}
+function isRefreshTokenValid(token, handicap = REFRESH_RENEW_HANDICAP_MS) {
+    const expireTime = token.refresh_token_expire_time || 0;
+    return expireTime - handicap > Date.now();
+}
+function isAccessTokenValid(token, handicap = DEFAULT_RENEW_HANDICAP_MS) {
+    const expireTime = token.expire_time || 0;
+    return expireTime - handicap > Date.now();
+}
+class RingCentral {
+    constructor(options) {
+        this._options = options;
+    }
+    loginUrl({ state }) {
+        const query = {
+            response_type: 'code',
+            redirect_uri: this._options.redirectUri,
+            client_id: this._options.clientId,
+            response_hint: 'brand_id contracted_country_code'
+        };
+        if (state) {
+            query.state = state;
+        }
+        return `${this._options.server}/restapi/oauth/authorize?${stringifyQuery(query)}`;
+    }
+    async generateToken({ code }) {
+        const body = {
+            code,
+            grant_type: 'authorization_code',
+            redirect_uri: this._options.redirectUri
+        };
+        const response = await this._tokenRequest('/restapi/oauth/token', body);
+        if (Number.parseInt(response.status, 10) >= 400) {
+            throw new Error('Generate Token error', response.status);
+        }
+        const { expires_in, refresh_token_expires_in, ...token } = await response.json();
+        return {
+            ...token,
+            expire_time: Date.now() + parseInt(expires_in, 10) * 1000,
+            refresh_token_expire_time: Date.now() + parseInt(refresh_token_expires_in, 10) * 1000
+        };
+    }
+    async refreshToken(token) {
+        const body = {
+            grant_type: 'refresh_token',
+            refresh_token: token.refresh_token,
+            access_token_ttl: token.expires_in,
+            refresh_token_ttl: token.refresh_token_expires_in
+        };
+        const response = await this._tokenRequest('/restapi/oauth/token', body);
+        if (Number.parseInt(response.status, 10) >= 400) {
+            const error = new Error('Refresh Token error', response.status);
+            error.response = response;
+            throw error;
+        }
+        const { expires_in, refresh_token_expires_in, ...newToken } = await response.json();
+        return {
+            ...newToken,
+            expire_time: Date.now() + parseInt(expires_in, 10) * 1000,
+            refresh_token_expire_time: Date.now() + parseInt(refresh_token_expires_in, 10) * 1000
+        };
+    }
+    async revokeToken(token) {
+        const body = {
+            token: token.access_token
+        };
+        const response = await this._tokenRequest('/restapi/oauth/revoke', body);
+        if (Number.parseInt(response.status, 10) >= 400) {
+            throw new Error('Revoke Token error', response.status);
+        }
+    }
+    async _tokenRequest(path, body) {
+        const authorization = `${this._options.clientId}:${this._options.clientSecret}`;
+        const response = await fetch(`${this._options.server}${path}`, {
+            method: 'POST',
+            body: stringifyQuery(body),
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Authorization': `Basic ${Buffer.from(authorization).toString('base64')}`
+            }
+        });
+        return response;
+    }
+    async request({ server = this._options.server, path, query, body, method, accept = 'application/json' }, token) {
+        let uri = `${server}${path}`;
+        if (query) {
+            uri = uri + (uri.includes('?') ? '&' : '?') + stringifyQuery(query);
+        }
+        const response = await fetch(uri, {
+            method,
+            body: body ? JSON.stringify(body) : body,
+            headers: {
+                'Accept': accept,
+                'Content-Type': 'application/json',
+                'Authorization': `${token.token_type} ${token.access_token}`
+            }
+        });
+        if (Number.parseInt(response.status, 10) >= 400) {
+            const error = new Error(`request data error ${response.status}`);
+            const errorText = await response.text();
+            error.message = errorText;
+            error.response = response;
+            throw error;
+        }
+        return response;
+    }
+    async createSubscription({ eventFilters, webhookUri }, token) {
+        const response = await this.request({
+            method: 'POST',
+            path: '/restapi/v1.0/subscription',
+            body: {
+                eventFilters,
+                deliveryMode: {
+                    transportType: 'WebHook',
+                    address: webhookUri
+                },
+                expiresIn: 7 * 24 * 3600
+            }
+        }, token);
+        const { ...subscription } = await response.json();
+        return subscription;
+    }
+    async getExtensionInfo(extensionId, token) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/restapi/v1.0/account/~/extension/${extensionId}`
+        }, token);
+        return response.json();
+    }
+    async getAccountInfo(token) {
+        const response = await this.request({
+            method: 'GET',
+            path: `/restapi/v1.0/account/~`
+        }, token);
+        return response.json();
+    }
+    async getCallsAggregationData({ token, timezone, timeFrom, timeTo, groupBy }) {
+        const body = {
+            grouping: {
+                groupBy
+            },
+            timeSettings: {
+                timeZone: timezone,
+                timeRange: {
+                    timeFrom,
+                    timeTo
+                }
+            },
+            responseOptions: {
+                counters: {
+                    callsByDirection: {
+                        aggregationType: 'Sum'
+                    },
+                    callsByResponse: {
+                        aggregationType: 'Sum'
+                    }
+                },
+                timers: {
+                    allCallsDuration: {
+                        aggregationType: 'Sum'
+                    }
+                }
+            }
+        };
+        const response = await this.request({
+            method: 'POST',
+            path: `/analytics/calls/v1/accounts/~/aggregation/fetch`,
+            body,
+            accept: 'application/json'
+        }, token);
+        return response.json();
+    }
+    async getCallLogData({ extensionId = '~', token, timeFrom, timeTo }) {
+        let pageStart = 1;
+        let isFinalPage = false;
+        let result = { records: [] };
+        while (!isFinalPage) {
+            const callLogResponse = await this.request({
+                method: 'GET',
+                path: `/restapi/v1.0/account/~/extension/${extensionId}/call-log?dateFrom=${timeFrom}&dateTo=${timeTo}&page=${pageStart}&view=Simple&perPage=1000`
+            }, token);
+            const resultJson = await callLogResponse.json();
+            result.records.push(...resultJson.records);
+            if (resultJson.navigation?.nextPage) {
+                pageStart++;
+            }
+            else {
+                isFinalPage = true;
+            }
+        }
+        return result;
+    }
+    async getSMSData({ extensionId = '~', token, timeFrom, timeTo }) {
+        let pageStart = 1;
+        let isFinalPage = false;
+        let result = { records: [] };
+        while (!isFinalPage) {
+            const smsLogResponse = await this.request({
+                method: 'GET',
+                path: `/restapi/v1.0/account/~/extension/${extensionId}/message-store?dateFrom=${timeFrom}&dateTo=${timeTo}&page=${pageStart}&perPage=100`
+            }, token);
+            const resultJson = await smsLogResponse.json();
+            result.records.push(...resultJson.records);
+            if (resultJson.navigation?.nextPage) {
+                pageStart++;
+            }
+            else {
+                isFinalPage = true;
+            }
+        }
+        return result;
+    }
+}
+exports.RingCentral = RingCentral;

package/dist/lib/s3ErrorLogReport.d.ts

@@ -0,0 +1,4 @@
+import type { UploadUrlParams } from '../types';
+declare function ensureBucketExists(): Promise<void>;
+declare function getUploadUrl({ userId, platform, metadata }: UploadUrlParams): Promise<string>;
+export { ensureBucketExists, getUploadUrl };

package/{lib → dist/lib}/s3ErrorLogReport.js

@@ -1,13 +1,14 @@
-// packages/core/lib/s3ErrorReport.js
-const { S3Client, PutObjectCommand, GetObjectCommand, CreateBucketCommand, HeadBucketCommand } = require('@aws-sdk/client-s3');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureBucketExists = ensureBucketExists;
+exports.getUploadUrl = getUploadUrl;
+const { S3Client, PutObjectCommand, CreateBucketCommand, HeadBucketCommand } = require('@aws-sdk/client-s3');
 const { getSignedUrl } = require('@aws-sdk/s3-request-presigner');
 const shortid = require('shortid');
-
 const BUCKET_NAME = process.env.ERROR_REPORT_S3_BUCKET || 'error-reports-bucket';
 const PRESIGN_EXPIRY = 300; // 5 minutes
 const IS_LOCAL = !process.env.ERROR_REPORT_S3_BUCKET;
 const LOCALSTACK_ENDPOINT = process.env.LOCALSTACK_ENDPOINT || 'http://localhost:9001';
-
 const s3Client = new S3Client({
     region: process.env.AWS_REGION || 'us-east-1',
     ...(IS_LOCAL && {
@@ -19,33 +20,25 @@ const s3Client = new S3Client({
         }
     })
 });
-
-/**
- * Ensure bucket exists (useful for local testing)
- */
 async function ensureBucketExists() {
-    if (!IS_LOCAL) return;
-    
+    if (!IS_LOCAL)
+        return;
     try {
         await s3Client.send(new HeadBucketCommand({ Bucket: BUCKET_NAME }));
-    } catch (err) {
-        if (err.name === 'NotFound' || err.$metadata?.httpStatusCode === 404) {
+    }
+    catch (err) {
+        const awsError = err;
+        if (awsError.name === 'NotFound' || awsError.$metadata?.httpStatusCode === 404) {
             await s3Client.send(new CreateBucketCommand({ Bucket: BUCKET_NAME }));
             console.log(`[LocalStack] Created bucket: ${BUCKET_NAME}`);
         }
     }
 }
-
-/**
- * Generate presigned URL for upload
- */
 async function getUploadUrl({ userId, platform, metadata }) {
     await ensureBucketExists();
-    
     const reportId = shortid.generate();
     const timestamp = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
     const key = `error-reports/${timestamp}/${userId}-${reportId}.json`;
-
     const command = new PutObjectCommand({
         Bucket: BUCKET_NAME,
         Key: key,
@@ -56,11 +49,6 @@ async function getUploadUrl({ userId, platform, metadata }) {
             ...metadata
         }
     });
-
     const uploadUrl = await getSignedUrl(s3Client, command, { expiresIn: PRESIGN_EXPIRY });
-
     return uploadUrl;
 }
-
-exports.getUploadUrl = getUploadUrl;
-exports.ensureBucketExists = ensureBucketExists;