@friggframework/core 2.0.0-next.104 → 2.0.0-next.106

package/credential/repositories/credential-repository-mongo.js

@@ -2,6 +2,7 @@ const { prisma } = require('../../database/prisma');
 const {
     CredentialRepositoryInterface,
 } = require('./credential-repository-interface');
+const { tallyActiveCredentialsByType } = require('./credential-active-type');
 
 /**
  * MongoDB Credential Repository Adapter
@@ -231,6 +232,30 @@ class CredentialRepositoryMongo extends CredentialRepositoryInterface {
         };
     }
 
+    /**
+     * Count credentials active since a timestamp, grouped by integration type.
+     *
+     * @param {Object} params
+     * @param {Date} [params.since] - Lower bound on updatedAt
+     * @returns {Promise<Array<{ integrationType: string, count: number }>>}
+     */
+    async countActiveByType({ since } = {}) {
+        const where = {};
+        if (since) where.updatedAt = { gte: since };
+
+        // Type lives on the related Entity.moduleName, not on Credential. Select
+        // only that field (+ id) so the encrypted `data` JSON is never decrypted.
+        const credentials = await this.prisma.credential.findMany({
+            where,
+            select: {
+                id: true,
+                entities: { select: { moduleName: true } },
+            },
+        });
+
+        return tallyActiveCredentialsByType(credentials);
+    }
+
     /**
      * Convert identifiers to Prisma where clause
      * @private

package/credential/repositories/credential-repository-postgres.js

@@ -2,6 +2,7 @@ const { prisma } = require('../../database/prisma');
 const {
     CredentialRepositoryInterface,
 } = require('./credential-repository-interface');
+const { tallyActiveCredentialsByType } = require('./credential-active-type');
 
 /**
  * PostgreSQL Credential Repository Adapter
@@ -248,6 +249,30 @@ class CredentialRepositoryPostgres extends CredentialRepositoryInterface {
         };
     }
 
+    /**
+     * Count credentials active since a timestamp, grouped by integration type.
+     *
+     * @param {Object} params
+     * @param {Date} [params.since] - Lower bound on updatedAt
+     * @returns {Promise<Array<{ integrationType: string, count: number }>>}
+     */
+    async countActiveByType({ since } = {}) {
+        const where = {};
+        if (since) where.updatedAt = { gte: since };
+
+        // Select only the entity moduleName (+ id) so the encrypted `data` JSON
+        // is never read and the encryption extension has nothing to decrypt.
+        const credentials = await this.prisma.credential.findMany({
+            where,
+            select: {
+                id: true,
+                entities: { select: { moduleName: true } },
+            },
+        });
+
+        return tallyActiveCredentialsByType(credentials);
+    }
+
     /**
      * Convert identifiers to Prisma where clause (converting IDs to Int)
      * @private

package/database/documentdb-utils.js

@@ -121,6 +121,60 @@ async function aggregate(client, collection, pipeline) {
     return result?.cursor?.firstBatch || [];
 }
 
+// findMany/aggregate return ONLY the first batch (~101 docs); the drained variants below follow the cursor to completion so full scans don't silently truncate.
+const DRAIN_BATCH_SIZE = 1000;
+const MAX_DRAIN_BATCHES = 100000;
+
+function isCursorOpen(id) {
+    if (id === undefined || id === null) return false;
+    if (typeof id === 'number') return id !== 0;
+    if (typeof id === 'bigint') return id !== 0n;
+    // Extended JSON can surface a 64-bit cursor id as { $numberLong: "..." }.
+    if (typeof id === 'object' && id.$numberLong !== undefined) {
+        return id.$numberLong !== '0';
+    }
+    return String(id) !== '0';
+}
+
+async function drainCursor(client, collection, firstResult) {
+    const cursor = firstResult?.cursor || {};
+    const docs = [...(cursor.firstBatch || [])];
+    let cursorId = cursor.id;
+    let batches = 0;
+
+    while (isCursorOpen(cursorId) && batches < MAX_DRAIN_BATCHES) {
+        batches += 1;
+        const next = await client.$runCommandRaw({
+            getMore: cursorId,
+            collection,
+            batchSize: DRAIN_BATCH_SIZE,
+        });
+        const nextCursor = next?.cursor || {};
+        const nextBatch = nextCursor.nextBatch || [];
+        docs.push(...nextBatch);
+        cursorId = nextCursor.id;
+        if (nextBatch.length === 0) break;
+    }
+    return docs;
+}
+
+async function findManyDrained(client, collection, filter = {}, options = {}) {
+    const command = { find: collection, filter, batchSize: DRAIN_BATCH_SIZE };
+    if (options.projection) command.projection = options.projection;
+    if (options.sort) command.sort = options.sort;
+    const first = await client.$runCommandRaw(command);
+    return drainCursor(client, collection, first);
+}
+
+async function aggregateDrained(client, collection, pipeline) {
+    const first = await client.$runCommandRaw({
+        aggregate: collection,
+        pipeline,
+        cursor: { batchSize: DRAIN_BATCH_SIZE },
+    });
+    return drainCursor(client, collection, first);
+}
+
 module.exports = {
     toObjectId,
     toObjectIdArray,
@@ -132,5 +186,7 @@ module.exports = {
     deleteOne,
     deleteMany,
     aggregate,
+    findManyDrained,
+    aggregateDrained,
 };
 

package/handlers/app-definition-loader.js

@@ -8,7 +8,7 @@ const { resolveTelemetryConfig } = require('../telemetry/telemetry-config');
  * @function loadAppDefinition
  * @description Searches for the nearest backend package.json, loads the corresponding index.js file,
  * and extracts the application definition containing integrations and user configuration.
- * @returns {{integrations: Array<object>, userConfig: object | null, adminScripts: Array<object>, admin: object, telemetry: object}} An object containing the application definition.
+ * @returns {{integrations: Array<object>, userConfig: object | null, adminScripts: Array<object>, reports: Array<object>, admin: object, telemetry: object}} An object containing the application definition.
  * @throws {Error} Throws error if backend package.json cannot be found.
  * @throws {Error} Throws error if index.js file cannot be found in the backend directory.
  * @example
@@ -34,6 +34,7 @@ function loadAppDefinition() {
         integrations = [],
         user: userConfig = null,
         adminScripts = [],
+        reports = [],
         admin = {},
     } = appDefinition;
 
@@ -58,7 +59,7 @@ function loadAppDefinition() {
         };
     }
 
-    return { integrations, userConfig, adminScripts, admin, telemetry };
+    return { integrations, userConfig, adminScripts, reports, admin, telemetry };
 }
 
 module.exports = {

package/index.js

@@ -66,8 +66,10 @@ const {
     LoadIntegrationContextUseCase,
 } = require('./integrations/index');
 const {
-    createReportingRouter,
-    createReportingRepository,
+    ReportBase,
+    IntegrationsReport,
+    BUILTIN_REPORTS,
+    createReportCommands,
 } = require('./reporting/index');
 const {
     createTelemetry,
@@ -144,8 +146,10 @@ module.exports = {
     GetProcess,
 
     // reporting
-    createReportingRouter,
-    createReportingRepository,
+    ReportBase,
+    IntegrationsReport,
+    BUILTIN_REPORTS,
+    createReportCommands,
 
     // telemetry
     createTelemetry,

package/integrations/integration-base.js

@@ -383,10 +383,7 @@ class IntegrationBase {
                     this.id,
                     'errors',
                     'Authentication Error',
-                    `There was an error with your ${this[
-                        module
-                    ].getName()} Entity.
-                Please reconnect/re-authenticate, or reach out to Support for assistance.`,
+                    this._authErrorMessage(this[module].getName()),
                     Date.now()
                 );
             }
@@ -395,6 +392,16 @@ class IntegrationBase {
         return didAuthPass;
     }
 
+    /**
+     * @param {string} [moduleName] - The module whose credentials failed.
+     * @param {number} [statusCode] - HTTP status the module rejected us with.
+     * @returns {string} A user-facing message.
+     */
+    _authErrorMessage(moduleName, statusCode) {
+        const status = statusCode ? ` (HTTP ${statusCode})` : '';
+        return `There was an error with your ${moduleName} Entity${status}. Please reconnect/re-authenticate, or reach out to Support for assistance.`;
+    }
+
     /**
      * Reconcile the auth-health axis (ERROR ↔ ENABLED) from a testAuth result.
      * On success it never clears DISABLED — a user pause is not an auth-health
@@ -848,6 +855,9 @@ class IntegrationBase {
         if (!this.id) return;
 
         if (delegateString === 'CREDENTIAL_INVALIDATED') {
+            if (this.status === 'ERROR') return;
+
+            const moduleName = notifier?.name;
             const detail =
                 object?.reason || object?.statusCode
                     ? ` (status ${object?.statusCode ?? '?'}: ${
@@ -856,11 +866,15 @@ class IntegrationBase {
                     : '';
             console.log(
                 `[Frigg] Module ${
-                    notifier?.name || '?'
+                    moduleName || '?'
                 } reported invalid credentials for integration ${
                     this.id
                 } — marking ERROR${detail}`
             );
+            await this._recordCredentialRejection(
+                moduleName,
+                object?.statusCode
+            );
             await this.persistStatus('ERROR');
             return;
         }
@@ -877,6 +891,30 @@ class IntegrationBase {
             await this.persistStatus('ENABLED');
         }
     }
+
+    /**
+     * Takes no `reason`: the delegate's is a FetchError message echoing the
+     * request, Authorization header included outside prod, and this is shown to
+     * end users. Best-effort so it cannot block the caller's status flip.
+     * @param {string} [moduleName] - The module that reported the rejection.
+     * @param {number} [statusCode] - HTTP status the module rejected us with.
+     */
+    async _recordCredentialRejection(moduleName, statusCode) {
+        try {
+            await this.updateIntegrationMessages.execute(
+                this.id,
+                'errors',
+                'Authentication Error',
+                this._authErrorMessage(moduleName, statusCode),
+                Date.now()
+            );
+        } catch (error) {
+            console.error(
+                `[Frigg] Failed to record credential rejection for integration ${this.id}:`,
+                error
+            );
+        }
+    }
 }
 
 module.exports = { IntegrationBase };

package/integrations/repositories/integration-mapping-repository-documentdb.js

@@ -8,6 +8,7 @@ const {
     updateOne,
     deleteOne,
     deleteMany,
+    aggregateDrained,
 } = require('../../database/documentdb-utils');
 const {
     IntegrationMappingRepositoryInterface,
@@ -15,6 +16,7 @@ const {
 const {
     DocumentDBEncryptionService,
 } = require('../../database/documentdb-encryption-service');
+
 class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositoryInterface {
     constructor() {
         super();
@@ -22,6 +24,27 @@ class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositor
         this.encryptionService = new DocumentDBEncryptionService();
     }
 
+    /**
+     * integrationId is stored as a string in DocumentDB, so ids are matched as
+     * strings (an ObjectId $in would never match). Drains the grouped cursor so
+     * a deployment-wide count is not truncated at the first batch.
+     */
+    async countByIntegrationIds(ids = []) {
+        const counts = new Map();
+        if (!ids || ids.length === 0) return counts;
+
+        const stringIds = ids.map(String);
+        const rows = await aggregateDrained(this.prisma, 'IntegrationMapping', [
+            { $match: { integrationId: { $in: stringIds } } },
+            { $group: { _id: '$integrationId', count: { $sum: 1 } } },
+        ]);
+
+        for (const row of rows) {
+            counts.set(String(row?._id), row?.count ?? 0);
+        }
+        return counts;
+    }
+
     async findMappingBy(integrationId, sourceId) {
         const filter = this._compositeFilter(integrationId, sourceId);
         const doc = await findOne(this.prisma, 'IntegrationMapping', filter);

package/integrations/repositories/integration-mapping-repository-interface.js

@@ -77,6 +77,20 @@ class IntegrationMappingRepositoryInterface {
         );
     }
 
+    /**
+     * Count mappings grouped by integration id, for a bounded set of ids.
+     * Adapters must drain the full grouped result (a deployment can have more
+     * than one first-batch of distinct integration ids).
+     *
+     * @returns {Promise<Map<string, number>>} Map of integrationId (string) → count
+     * @abstract
+     */
+    async countByIntegrationIds(ids) {
+        throw new Error(
+            'Method countByIntegrationIds must be implemented by subclass'
+        );
+    }
+
     /**
      * Find mapping by ID
      *

package/integrations/repositories/integration-mapping-repository-mongo.js

@@ -133,6 +133,28 @@ class IntegrationMappingRepositoryMongo extends IntegrationMappingRepositoryInte
         };
     }
 
+    /**
+     * Count mappings grouped by integration id for a bounded id set.
+     *
+     * @param {Array<string>} ids - Integration ids
+     * @returns {Promise<Map<string, number>>} integrationId (string) → count
+     */
+    async countByIntegrationIds(ids = []) {
+        const counts = new Map();
+        if (!ids || ids.length === 0) return counts;
+
+        const groups = await this.prisma.integrationMapping.groupBy({
+            by: ['integrationId'],
+            where: { integrationId: { in: ids } },
+            _count: { _all: true },
+        });
+
+        for (const group of groups) {
+            counts.set(String(group.integrationId), group._count._all);
+        }
+        return counts;
+    }
+
     /**
      * Find mapping by ID
      * @param {string} id - Mapping ID

package/integrations/repositories/integration-mapping-repository-postgres.js

@@ -2,6 +2,7 @@ const { prisma } = require('../../database/prisma');
 const {
     IntegrationMappingRepositoryInterface,
 } = require('./integration-mapping-repository-interface');
+const { strictIntId } = require('./report-id');
 
 /**
  * PostgreSQL Integration Mapping Repository Adapter
@@ -188,6 +189,33 @@ class IntegrationMappingRepositoryPostgres extends IntegrationMappingRepositoryI
         };
     }
 
+    /**
+     * Count mappings grouped by integration id for a bounded id set.
+     *
+     * @param {Array<string|number>} ids - Integration ids
+     * @returns {Promise<Map<string, number>>} integrationId (string) → count
+     */
+    async countByIntegrationIds(ids = []) {
+        const counts = new Map();
+        if (!ids || ids.length === 0) return counts;
+
+        // Strict (matches findAllForReport): reject partially-numeric ids instead of coercing.
+        const intIds = ids.map((id) => strictIntId(id));
+        const groups = await this.prisma.integrationMapping.groupBy({
+            by: ['integrationId'],
+            where: { integrationId: { in: intIds } },
+            _count: { _all: true },
+        });
+
+        for (const group of groups) {
+            counts.set(
+                this._intToString(group.integrationId),
+                group._count._all
+            );
+        }
+        return counts;
+    }
+
     /**
      * Find mapping by ID
      * @param {string} id - Mapping ID (string from application layer)

package/integrations/repositories/integration-repository-documentdb.js

@@ -4,6 +4,7 @@ const {
     toObjectIdArray,
     fromObjectId,
     findMany,
+    findManyDrained,
     findOne,
     insertOne,
     updateOne,
@@ -254,6 +255,43 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         return this._mapIntegration(updated);
     }
 
+    // Drain the full cursor so a deployment-wide report is never truncated.
+    async findAllForReport({ status, userId } = {}) {
+        const filter = {};
+        if (status) filter.status = status;
+        if (userId !== undefined && userId !== null) {
+            const objectId = toObjectId(userId);
+            // Invalid userId means no matches — don't fall through to an unfiltered whole-deployment query.
+            if (!objectId) return [];
+            filter.userId = objectId;
+        }
+
+        const docs = await findManyDrained(this.prisma, 'Integration', filter);
+
+        return docs.map((doc) => {
+            const errors = this._extractReportErrors(doc);
+            return {
+                id: fromObjectId(doc?._id),
+                type: doc?.config?.type ?? null,
+                status: doc?.status ?? null,
+                userId: fromObjectId(doc?.userId) ?? null,
+                version: doc?.version ?? null,
+                errorCount: Array.isArray(errors) ? errors.length : 0,
+                moduleCount: Array.isArray(doc?.entityIds)
+                    ? doc.entityIds.length
+                    : 0,
+                createdAt: doc?.createdAt ?? null,
+                updatedAt: doc?.updatedAt ?? null,
+            };
+        });
+    }
+
+    _extractReportErrors(doc) {
+        if (Array.isArray(doc?.errors)) return doc.errors;
+        if (Array.isArray(doc?.messages?.errors)) return doc.messages.errors;
+        return [];
+    }
+
     _mapIntegration(doc) {
         const messages = this._extractMessages(doc);
         return {

package/integrations/repositories/integration-repository-interface.js

@@ -35,6 +35,22 @@ class IntegrationRepositoryInterface {
         throw new Error('Method findIntegrations must be implemented by subclass');
     }
 
+    /**
+     * Find every integration in a report-shaped projection, optionally
+     * filtered by status and/or owning user. Adapters must drain the full
+     * result set (no first-batch truncation) since this powers a
+     * deployment-wide scan.
+     *
+     * @param {Object} [filter={}]
+     * @param {string} [filter.status] - Integration status
+     * @param {string|number} [filter.userId] - Owning user ID
+     * @returns {Promise<Array<{id, type, status, userId, version, errorCount, moduleCount, createdAt, updatedAt}>>}
+     * @abstract
+     */
+    async findAllForReport(filter = {}) {
+        throw new Error('Method findAllForReport must be implemented by subclass');
+    }
+
     /**
      * Delete integration by ID
      *

package/integrations/repositories/integration-repository-mongo.js

@@ -89,6 +89,42 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         }));
     }
 
+    /**
+     * Find every integration in a report-shaped projection.
+     *
+     * type lives in config.type (a JSON path not portably groupable across
+     * DBs); it is left in the row for the caller to bucket.
+     *
+     * @param {Object} [filter={}]
+     * @param {string} [filter.status] - Integration status
+     * @param {string} [filter.userId] - Owning user ID (ObjectId as string)
+     * @returns {Promise<Array>} Report-shaped integration rows
+     */
+    async findAllForReport({ status, userId } = {}) {
+        const where = {};
+        if (status) where.status = status;
+        if (userId !== undefined && userId !== null) where.userId = userId;
+
+        const integrations = await this.prisma.integration.findMany({
+            where,
+            include: { entities: { select: { id: true } } },
+        });
+
+        return integrations.map((integration) => ({
+            id: integration.id,
+            type: integration.config?.type ?? null,
+            status: integration.status ?? null,
+            userId: integration.userId ?? null,
+            version: integration.version ?? null,
+            errorCount: Array.isArray(integration.errors)
+                ? integration.errors.length
+                : 0,
+            moduleCount: integration.entities?.length ?? 0,
+            createdAt: integration.createdAt ?? null,
+            updatedAt: integration.updatedAt ?? null,
+        }));
+    }
+
     /**
      * Delete integration by ID
      * Replaces: IntegrationModel.deleteOne({ _id: integrationId })

package/integrations/repositories/integration-repository-postgres.js

@@ -3,6 +3,7 @@ const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
+const { strictIntId } = require('./report-id');
 
 /**
  * PostgreSQL Integration Repository Adapter
@@ -129,6 +130,45 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         });
     }
 
+    /**
+     * Find every integration in a report-shaped projection.
+     *
+     * type lives in config.type (a JSON path not portably groupable across
+     * DBs); it is left in the row for the caller to bucket.
+     *
+     * @param {Object} [filter={}]
+     * @param {string} [filter.status] - Integration status
+     * @param {string|number} [filter.userId] - Owning user ID
+     * @returns {Promise<Array>} Report-shaped integration rows
+     */
+    async findAllForReport({ status, userId } = {}) {
+        const where = {};
+        if (status) where.status = status;
+        if (userId !== undefined && userId !== null) {
+            // Strict: parseInt would coerce '12abc'/'12.9' to 12 and read the wrong user.
+            where.userId = strictIntId(userId);
+        }
+
+        const integrations = await this.prisma.integration.findMany({
+            where,
+            include: { entities: { select: { id: true } } },
+        });
+
+        return integrations.map((integration) => ({
+            id: integration.id?.toString(),
+            type: integration.config?.type ?? null,
+            status: integration.status ?? null,
+            userId: integration.userId?.toString() ?? null,
+            version: integration.version ?? null,
+            errorCount: Array.isArray(integration.errors)
+                ? integration.errors.length
+                : 0,
+            moduleCount: integration.entities?.length ?? 0,
+            createdAt: integration.createdAt ?? null,
+            updatedAt: integration.updatedAt ?? null,
+        }));
+    }
+
     /**
      * Delete integration by ID
      *

package/integrations/repositories/report-id.js

@@ -0,0 +1,13 @@
+/**
+ * Coerces an id to an integer, rejecting partially-numeric input ('12abc',
+ * '12.9') that parseInt would silently truncate to 12 and read the wrong record.
+ */
+function strictIntId(id) {
+    const str = String(id).trim();
+    if (!/^-?\d+$/.test(str)) {
+        throw new TypeError(`Invalid ID: ${id} cannot be converted to integer`);
+    }
+    return Number.parseInt(str, 10);
+}
+
+module.exports = { strictIntId };

package/modules/requester/oauth-2.js

@@ -322,6 +322,11 @@ class OAuth2Requester extends Requester {
                 response_status: error?.response?.status,
                 response_data: error?.response?.data,
             });
+            // Status only: the refresh body carries client_secret, and
+            // FetchError embeds the body in its message outside prod.
+            await this.notify(this.DLGT_INVALID_AUTH, {
+                statusCode: error?.statusCode,
+            });
             return false;
         }
     }
@@ -353,8 +358,13 @@ class OAuth2Requester extends Requester {
 
             await this.setTokens(tokenRes);
             return tokenRes;
-        } catch {
-            await this.notify(this.DLGT_INVALID_AUTH);
+        } catch (error) {
+            // Status only. This request's body holds the password or client
+            // secret, and FetchError embeds the body in its message outside
+            // prod, so forwarding the error itself would log the credential.
+            await this.notify(this.DLGT_INVALID_AUTH, {
+                statusCode: error?.statusCode,
+            });
         }
     }
 
@@ -387,8 +397,13 @@ class OAuth2Requester extends Requester {
 
             await this.setTokens(tokenRes);
             return tokenRes;
-        } catch {
-            await this.notify(this.DLGT_INVALID_AUTH);
+        } catch (error) {
+            // Status only. This request's body holds the password or client
+            // secret, and FetchError embeds the body in its message outside
+            // prod, so forwarding the error itself would log the credential.
+            await this.notify(this.DLGT_INVALID_AUTH, {
+                statusCode: error?.statusCode,
+            });
         }
     }
 }