@app-connect/core 1.7.5 → 1.7.8

package/lib/debugTracer.js

@@ -0,0 +1,159 @@
+class DebugTracer {
+    /**
+     * Creates a new DebugTracer instance
+     * @param {Object} headers - Request headers object
+     */
+    constructor(headers = {}) {
+        this.traces = [];
+        this.startTime = Date.now();
+        this.requestId = this._generateRequestId();
+    }
+
+    /**
+     * Generates a unique request ID for tracking
+     * @returns {string} Unique request ID
+     */
+    _generateRequestId() {
+        return `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+
+    /**
+     * Captures the current stack trace
+     * @param {number} skipFrames - Number of frames to skip from the top (default: 2)
+     * @returns {string[]} Array of stack trace lines
+     */
+    _captureStackTrace(skipFrames = 2) {
+        const err = new Error();
+        const stack = err.stack || '';
+        const lines = stack.split('\n').slice(skipFrames);
+        return lines.map(line => line.trim()).filter(line => line.startsWith('at '));
+    }
+
+    /**
+     * Records a trace entry with method name, data, and stack trace
+     * @param {string} methodName - Name of the method/function being traced
+     * @param {Object} data - Data to record (will be sanitized to remove sensitive info)
+     * @param {Object} options - Additional options
+     * @param {boolean} options.includeStack - Whether to include stack trace (default: true)
+     * @param {string} options.level - Log level: 'info', 'warn', 'error' (default: 'info')
+     * @returns {DebugTracer} Returns this for chaining
+     */
+    trace(methodName, data = {}, options = {}) {
+        const { includeStack = true, level = 'info' } = options;
+        
+        const traceEntry = {
+            timestamp: new Date().toISOString(),
+            elapsed: Date.now() - this.startTime,
+            methodName,
+            level,
+            data: this._sanitizeData(data)
+        };
+
+        if (includeStack) {
+            traceEntry.stackTrace = this._captureStackTrace(3);
+        }
+
+        this.traces.push(traceEntry);
+        return this;
+    }
+
+    /**
+     * Records an error trace with full stack information
+     * @param {string} methodName - Name of the method where error occurred
+     * @param {Error|string} error - Error object or message
+     * @param {Object} additionalData - Additional context data
+     * @returns {DebugTracer} Returns this for chaining
+     */
+    traceError(methodName, error, additionalData = {}) {
+        const errorData = {
+            message: error instanceof Error ? error.message : String(error),
+            errorStack: error instanceof Error ? error.stack : null,
+            ...additionalData
+        };
+
+        return this.trace(methodName, errorData, { level: 'error' });
+    }
+
+    /**
+     * Sanitizes data by removing sensitive fields
+     * @param {Object} data - Data to sanitize
+     * @returns {Object} Sanitized data
+     */
+    _sanitizeData(data) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+
+        const sensitiveFields = [
+            'accessToken', 'refreshToken', 'apiKey', 'password', 
+            'secret', 'token', 'authorization', 'auth', 'key',
+            'credential', 'credentials', 'privateKey', 'clientSecret'
+        ];
+
+        const sanitized = Array.isArray(data) ? [...data] : { ...data };
+
+        const sanitizeRecursive = (obj) => {
+            if (!obj || typeof obj !== 'object') {
+                return obj;
+            }
+
+            for (const key of Object.keys(obj)) {
+                const lowerKey = key.toLowerCase();
+                if (sensitiveFields.some(field => lowerKey.includes(field.toLowerCase()))) {
+                    // eslint-disable-next-line no-param-reassign
+                    obj[key] = '[REDACTED]';
+                } else if (typeof obj[key] === 'object' && obj[key] !== null) {
+                    // eslint-disable-next-line no-param-reassign
+                    obj[key] = sanitizeRecursive(
+                        Array.isArray(obj[key]) ? [...obj[key]] : { ...obj[key] }
+                    );
+                }
+            }
+            return obj;
+        };
+
+        return sanitizeRecursive(sanitized);
+    }
+
+    /**
+     * Gets the complete trace data for inclusion in response
+     * @returns {Object} Trace data object
+     */
+    getTraceData() {
+        return {
+            requestId: this.requestId,
+            totalDuration: `${Date.now() - this.startTime}ms`,
+            traceCount: this.traces.length,
+            traces: this.traces
+        };
+    }
+
+    /**
+     * Gets trace data and merges it into a response object
+     * @param {Object} response - Original response object
+     * @returns {Object} Response with debug trace data appended (if debug mode enabled)
+     */
+    wrapResponse(response) {
+        const traceData = this.getTraceData();
+        if (!traceData) {
+            return response;
+        }
+
+        return {
+            ...response,
+            _debug: traceData
+        };
+    }
+
+    /**
+     * Static helper to create tracer from Express request
+     * @param {Object} req - Express request object
+     * @returns {DebugTracer} New tracer instance
+     */
+    static fromRequest(req) {
+        return new DebugTracer(req.headers || {});
+    }
+}
+
+module.exports = { DebugTracer };
+

package/lib/oauth.js

@@ -32,7 +32,7 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20)
     // 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)) {
+        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
@@ -40,7 +40,7 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20)
                 newLock = await Lock.create(
                     {
                         userId: user.id,
-                        ttl: now.unix() + 30
+                        ttl: now.unix() + tokenLockTimeout
                     },
                     {
                         overwrite: false
@@ -59,7 +59,7 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20)
                             newLock = await Lock.create(
                                 {
                                     userId: user.id,
-                                    ttl: now.unix() + 30
+                                    ttl: now.unix() + tokenLockTimeout
                                 },
                                 {
                                     overwrite: false
@@ -97,22 +97,32 @@ async function checkAndRefreshAccessToken(oauthApp, user, tokenLockTimeout = 20)
                     throw e;
                 }
             }
-            const startRefreshTime = moment();
-            const token = oauthApp.createToken(user.accessToken, user.refreshToken);
-            console.log('token refreshing...')
-            const { accessToken, refreshToken, expires } = await token.refresh();
-            user.accessToken = accessToken;
-            user.refreshToken = refreshToken;
-            user.tokenExpiry = expires;
-            await user.save();
-            if (newLock) {
-                const deletionStartTime = moment();
-                await newLock.delete();
-                const deletionEndTime = moment();
-                console.log(`lock deleted in ${deletionEndTime.diff(deletionStartTime)}ms`)
+            try {
+                const startRefreshTime = moment();
+                const token = oauthApp.createToken(user.accessToken, user.refreshToken);
+                console.log('token refreshing...')
+                const { accessToken, refreshToken, expires } = await token.refresh();
+                user.accessToken = accessToken;
+                user.refreshToken = refreshToken;
+                user.tokenExpiry = expires;
+                await user.save();
+                if (newLock) {
+                    const deletionStartTime = moment();
+                    await newLock.delete();
+                    const deletionEndTime = moment();
+                    console.log(`lock deleted in ${deletionEndTime.diff(deletionStartTime)}ms`)
+                }
+                const endRefreshTime = moment();
+                console.log(`token refreshing finished in ${endRefreshTime.diff(startRefreshTime)}ms`)
+            }
+            catch (e) {
+                console.log('token refreshing failed', e.stack)
+            }
+            finally {
+                if (newLock) {
+                    await newLock.delete();
+                }
             }
-            const endRefreshTime = moment();
-            console.log(`token refreshing finished in ${endRefreshTime.diff(startRefreshTime)}ms`)
         }
         // case: run withou token refresh lock
         else {

package/lib/ringcentral.js

@@ -189,10 +189,10 @@ class RingCentral {
     return response.json();
   }
 
-  async getCallsAggregationData({ token, timezone, timeFrom, timeTo }) {
+  async getCallsAggregationData({ token, timezone, timeFrom, timeTo, groupBy }) {
     const body = {
       grouping: {
-        groupBy: "Company"
+        groupBy
       },
       timeSettings: {
         timeZone: timezone,

package/lib/s3ErrorLogReport.js

@@ -0,0 +1,66 @@
+// packages/core/lib/s3ErrorReport.js
+const { S3Client, PutObjectCommand, GetObjectCommand, 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 && {
+        endpoint: LOCALSTACK_ENDPOINT,
+        forcePathStyle: true, // Required for LocalStack/MinIO
+        credentials: {
+            accessKeyId: 'minioadmin',
+            secretAccessKey: 'minioadmin'
+        }
+    })
+});
+
+/**
+ * Ensure bucket exists (useful for local testing)
+ */
+async function ensureBucketExists() {
+    if (!IS_LOCAL) return;
+    
+    try {
+        await s3Client.send(new HeadBucketCommand({ Bucket: BUCKET_NAME }));
+    } catch (err) {
+        if (err.name === 'NotFound' || err.$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,
+        ContentType: 'application/json',
+        Metadata: {
+            'user-id': userId,
+            'platform': platform,
+            ...metadata
+        }
+    });
+
+    const uploadUrl = await getSignedUrl(s3Client, command, { expiresIn: PRESIGN_EXPIRY });
+
+    return uploadUrl;
+}
+
+exports.getUploadUrl = getUploadUrl;
+exports.ensureBucketExists = ensureBucketExists;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "1.7.5",
+  "version": "1.7.8",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {
@@ -16,13 +16,15 @@
   "peerDependencies": {
     "axios": "^1.12.2",
     "express": "^4.21.2",
-    "pg": "^8.8.0",
-    "sequelize": "^6.29.0",
     "moment": "^2.29.4",
-    "moment-timezone": "^0.5.39"
+    "moment-timezone": "^0.5.39",
+    "pg": "^8.8.0",
+    "sequelize": "^6.29.0"
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.751.0",
+    "@aws-sdk/client-s3": "^3.947.0",
+    "@aws-sdk/s3-request-presigner": "^3.947.0",
     "body-parser": "^1.20.3",
     "client-oauth2": "^4.3.3",
     "cors": "^2.8.5",
@@ -45,8 +47,8 @@
     "@eslint/js": "^9.22.0",
     "@octokit/rest": "^19.0.5",
     "axios": "^1.12.2",
-    "express": "^4.21.2",
     "eslint": "^9.22.0",
+    "express": "^4.21.2",
     "globals": "^16.0.0",
     "jest": "^29.3.1",
     "moment": "^2.29.4",

package/releaseNotes.json

@@ -1,4 +1,48 @@
 {
+    "1.7.8": {
+        "global": [
+            {
+                "type": "New",
+                "description": "Error report feature on support page"
+            },
+            {
+                "type": "Better",
+                "description": "Calldown list supports better edit feature"
+            },
+            {
+                "type": "Better",
+                "description": "Connctor selection list can be opened back again"
+            },
+            {
+                "type": "Fix",
+                "description": "Call log record is shown with a wrong number after the call"
+            }
+        ]
+    },
+    "1.7.7": {
+        "global": [
+            {
+                "type": "New",
+                "description": "Admin report company stats now support grouping"
+            },
+            {
+                "type": "New",
+                "description": "Users can open back the platform selection page from user setting page"
+            }
+        ]
+    },
+    "1.7.6": {
+        "global": [
+            {
+                "type": "Fix",
+                "description": "Duplicated contact pop when complete warm transfer"
+            },
+            {
+                "type": "Fix",
+                "description": "Multi-region auth"
+            }
+        ]
+    },
     "1.7.5": {
         "global": [
             {