@app-connect/core 1.7.36 → 1.7.37

package/index.js

@@ -34,7 +34,7 @@ const { DebugTracer } = require('./lib/debugTracer');
 const s3ErrorLogReport = require('./lib/s3ErrorLogReport');
 const pluginCore = require('./handlers/plugin');
 const { sequelize } = require('./models/sequelize');
-const { ensureCallLogsHashedExtensionIdSchema } = require('./lib/migrateCallLogsSchema');
+const { runCallLogsSchemaMigration } = require('./lib/migrateCallLogsSchema');
 const { handleDatabaseError } = require('./lib/errorHandler');
 const { updateAuthSession } = require('./lib/authSession');
 const managedAuthCore = require('./handlers/managedAuth');
@@ -73,7 +73,6 @@ async function initDB() {
         await UserModel.sync();
         await LlmSessionModel.sync();
         await CallLogModel.sync();
-        await ensureCallLogsHashedExtensionIdSchema(sequelize);
         await MessageLogModel.sync();
         await AdminConfigModel.sync();
         await CacheModel.sync();
@@ -3125,6 +3124,16 @@ async function initializeCore(options = {}) {
 
     if (!skipDatabaseInit) {
         await initDB();
+        // Run the heavy callLogs primary-key migration in the BACKGROUND, off the
+        // readiness critical path. It must not gate coreInit: on a large production
+        // table the index rebuild takes minutes, and blocking here would stall every
+        // request (including the load-balancer health check) and fail the deploy.
+        // The runner is self-guarding (advisory-locked across instances, idempotent,
+        // never throws) and uses online DDL on Postgres so live traffic is unaffected.
+        // Gated on the same flag as the schema sync so operators have one switch.
+        if (!process.env.DISABLE_SYNC_DB_TABLE) {
+            runCallLogsSchemaMigration(sequelize, logger);
+        }
     }
 }
 

package/lib/migrateCallLogsSchema.js

@@ -227,6 +227,191 @@ async function ensureCallLogsHashedExtensionIdSchema(sequelize) {
     }
 }
 
+// Dedicated name for the online-built unique index that becomes the new PK.
+const IDENTITY_INDEX_NAME = 'callLogs_identity_pk';
+// Stable application-wide key for the Postgres advisory lock that serializes the
+// migration across concurrently-booting instances. Any fixed integer works as long
+// as it is unique within the app; keep it constant so every instance agrees on it.
+const CALL_LOGS_MIGRATION_LOCK_KEY = 4972001;
+
+async function postgresPrimaryKeyNameOnConnection(client) {
+    const { rows } = await client.query(
+        `SELECT conname FROM pg_constraint
+         WHERE conrelid = '"${CALL_LOGS_TABLE}"'::regclass AND contype = 'p' LIMIT 1`,
+    );
+    return rows[0]?.conname ?? null;
+}
+
+async function postgresPkIncludesIdentityOnConnection(client) {
+    const { rows } = await client.query(
+        `SELECT kcu.column_name AS col
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON kcu.constraint_name = tc.constraint_name
+          AND kcu.table_name = tc.table_name
+         WHERE tc.table_name = $1 AND tc.constraint_type = 'PRIMARY KEY'`,
+        [CALL_LOGS_TABLE],
+    );
+    const cols = rows.map((r) => String(r.col).toLowerCase());
+    return CALL_LOG_IDENTITY_PK_COLUMNS.every((c) => cols.includes(c.toLowerCase()));
+}
+
+async function postgresColumnIsNullableOnConnection(client, column) {
+    const { rows } = await client.query(
+        `SELECT is_nullable FROM information_schema.columns
+         WHERE table_name = $1 AND column_name = $2`,
+        [CALL_LOGS_TABLE, column],
+    );
+    return rows[0]?.is_nullable === 'YES';
+}
+
+// 'absent' | 'valid' | 'invalid' — an INVALID index is the residue of a
+// CONCURRENTLY build that was interrupted (process killed, connection dropped).
+async function postgresIdentityIndexState(client) {
+    const { rows } = await client.query(
+        `SELECT (i.indisvalid AND i.indisready) AS ok
+         FROM pg_class c
+         JOIN pg_index i ON i.indexrelid = c.oid
+         WHERE c.relname = $1`,
+        [IDENTITY_INDEX_NAME],
+    );
+    if (rows.length === 0) return 'absent';
+    return rows[0].ok ? 'valid' : 'invalid';
+}
+
+/**
+ * Online (non-blocking) Postgres migration.
+ *
+ * Adds the hashedExtensionId column and rebuilds the primary key to the call-log
+ * identity WITHOUT holding an ACCESS EXCLUSIVE lock for the duration of the index
+ * build. This is the safe path for large production tables:
+ *   - ADD COLUMN ... NOT NULL DEFAULT '' is metadata-only on PG 11+.
+ *   - CREATE UNIQUE INDEX CONCURRENTLY builds the index while reads/writes continue.
+ *   - ADD PRIMARY KEY USING INDEX attaches the prebuilt index with only a brief lock.
+ *
+ * Runs on a single dedicated pooled connection so the advisory lock and the
+ * (necessarily non-transactional) CONCURRENTLY statements share one backend session.
+ */
+async function ensureCallLogsHashedExtensionIdSchemaPostgresOnline(sequelize, logger) {
+    // Cheap pre-check on a pooled connection; skip entirely once migrated.
+    if (await postgresCallLogsPkIncludesHashedExtension(sequelize)) {
+        return;
+    }
+
+    const connectionManager = sequelize.connectionManager;
+    const client = await connectionManager.getConnection({ type: 'write' });
+    let lockAcquired = false;
+    try {
+        const lockRes = await client.query(
+            `SELECT pg_try_advisory_lock(${CALL_LOGS_MIGRATION_LOCK_KEY}) AS locked`,
+        );
+        lockAcquired = lockRes.rows[0]?.locked === true;
+        if (!lockAcquired) {
+            logger?.info?.('[callLogs migration] another instance is migrating; skipping this run');
+            return;
+        }
+
+        // Re-check under the lock — another instance may have finished between the
+        // pre-check and acquiring the lock.
+        if (await postgresPkIncludesIdentityOnConnection(client)) {
+            return;
+        }
+
+        logger?.info?.('[callLogs migration] starting online migration (add column + rebuild primary key)');
+
+        // A server-side statement_timeout (common in RDS parameter groups) would abort
+        // the long CONCURRENTLY build and leave an INVALID index. Disable it for this
+        // session only; it is reset before the connection returns to the pool.
+        await client.query(`SET statement_timeout = 0`);
+
+        // 1. Add the column (metadata-only on PG 11+, safe to repeat).
+        await client.query(
+            `ALTER TABLE "${CALL_LOGS_TABLE}" ADD COLUMN IF NOT EXISTS "${HASHED_EXTENSION_ID_COLUMN}" varchar(255) NOT NULL DEFAULT ''`,
+        );
+
+        // 2. Primary-key columns must be NOT NULL. Only touch extensionNumber if needed.
+        if (await postgresColumnIsNullableOnConnection(client, 'extensionNumber')) {
+            await client.query(
+                `UPDATE "${CALL_LOGS_TABLE}" SET "extensionNumber" = '' WHERE "extensionNumber" IS NULL`,
+            );
+            await client.query(
+                `ALTER TABLE "${CALL_LOGS_TABLE}" ALTER COLUMN "extensionNumber" SET NOT NULL`,
+            );
+        }
+
+        // 3. Build the unique index without blocking traffic (cannot run in a transaction).
+        //    Reuse an already-valid index from a prior run so a failed *attach* (step 4)
+        //    never forces us to redo the expensive build; only rebuild if it is missing
+        //    or was left INVALID by an interrupted run.
+        const indexState = await postgresIdentityIndexState(client);
+        if (indexState === 'invalid') {
+            await client.query(`DROP INDEX CONCURRENTLY IF EXISTS "${IDENTITY_INDEX_NAME}"`);
+        }
+        if (indexState !== 'valid') {
+            await client.query(
+                `CREATE UNIQUE INDEX CONCURRENTLY "${IDENTITY_INDEX_NAME}" ON "${CALL_LOGS_TABLE}" (${CALL_LOG_IDENTITY_PK_COLUMNS.map((c) => `"${c}"`).join(', ')})`,
+            );
+        }
+
+        // 4. Swap the primary key onto the prebuilt index (brief ACCESS EXCLUSIVE lock,
+        //    no rebuild). Bound the lock wait so that if a long-running query holds the
+        //    table we fail fast and retry next boot, instead of parking an exclusive-lock
+        //    request at the head of the queue and stalling all traffic behind it.
+        await client.query(`SET lock_timeout = '5s'`);
+        const pkName = await postgresPrimaryKeyNameOnConnection(client);
+        if (pkName) {
+            await client.query(
+                `ALTER TABLE "${CALL_LOGS_TABLE}" DROP CONSTRAINT "${pkName}", ADD PRIMARY KEY USING INDEX "${IDENTITY_INDEX_NAME}"`,
+            );
+        } else {
+            await client.query(
+                `ALTER TABLE "${CALL_LOGS_TABLE}" ADD PRIMARY KEY USING INDEX "${IDENTITY_INDEX_NAME}"`,
+            );
+        }
+
+        logger?.info?.('[callLogs migration] completed');
+    } finally {
+        // Restore session defaults before the connection goes back to the pool, so no
+        // other query inherits statement_timeout=0 / the short lock_timeout.
+        try {
+            await client.query('RESET statement_timeout');
+            await client.query('RESET lock_timeout');
+        } catch (e) {
+            logger?.warn?.('[callLogs migration] failed to reset session settings', { message: e?.message });
+        }
+        if (lockAcquired) {
+            try {
+                await client.query(`SELECT pg_advisory_unlock(${CALL_LOGS_MIGRATION_LOCK_KEY})`);
+            } catch (e) {
+                logger?.warn?.('[callLogs migration] failed to release advisory lock', { message: e?.message });
+            }
+        }
+        connectionManager.releaseConnection(client);
+    }
+}
+
+/**
+ * Automatic entry point. Safe to call fire-and-forget off the startup critical path:
+ * it never throws (failures are logged and retried on the next boot) and, on Postgres,
+ * never blocks readiness or live traffic.
+ */
+async function runCallLogsSchemaMigration(sequelize, logger) {
+    try {
+        const dialect = sequelize.getDialect();
+        if (dialect === 'postgres') {
+            await ensureCallLogsHashedExtensionIdSchemaPostgresOnline(sequelize, logger);
+        } else {
+            // sqlite / local / tests: tables are tiny, the transactional rebuild is instant.
+            await ensureCallLogsHashedExtensionIdSchema(sequelize);
+        }
+    } catch (e) {
+        logger?.error?.('[callLogs migration] failed; will retry on next start', {
+            message: e?.message,
+            stack: e?.stack,
+        });
+    }
+}
+
 module.exports = {
     findColumnKey,
     migrateCallLogsExtensionNumberSqlite,
@@ -234,4 +419,6 @@ module.exports = {
     sqliteCallLogsPkIncludesExtension,
     sqliteCallLogsPkIncludesHashedExtension,
     ensureCallLogsHashedExtensionIdSchema,
+    ensureCallLogsHashedExtensionIdSchemaPostgresOnline,
+    runCallLogsSchemaMigration,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "1.7.36",
+  "version": "1.7.37",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {

package/releaseNotes.json

@@ -1,5 +1,5 @@
 {
-    "1.7.36": {
+    "1.7.37": {
         "global": [
             {
                 "type": "New",
@@ -9,6 +9,10 @@
                 "type": "New",
                 "description": "New option for auto log multi match resolver - Earliest created"
             },
+            {
+                "type": "Fix",
+                "description": "Shared SMS sending for company main number"
+            },
             {
                 "type": "Fix",
                 "description": "Server-side logging call log id inconsistency"