@friggframework/core 2.0.0-next.103 → 2.0.0-next.105

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/database/use-cases/resolve-migration-via-worker-use-case.js

@@ -0,0 +1,49 @@
+/**
+ * Resolve Migration Via Worker Use Case
+ *
+ * Resolves a failed Prisma migration (P3009) by invoking the worker Lambda,
+ * which has the Prisma CLI installed. Keeps the router Lambda lightweight —
+ * same delegation pattern as GetDatabaseStateViaWorkerUseCase.
+ */
+class ResolveMigrationViaWorkerUseCase {
+    /**
+     * @param {Object} dependencies
+     * @param {LambdaInvoker} dependencies.lambdaInvoker - Lambda invocation adapter
+     * @param {string} dependencies.workerFunctionName - Worker Lambda function name
+     */
+    constructor({ lambdaInvoker, workerFunctionName }) {
+        if (!lambdaInvoker) {
+            throw new Error('lambdaInvoker dependency is required');
+        }
+        if (!workerFunctionName) {
+            throw new Error('workerFunctionName is required');
+        }
+        this.lambdaInvoker = lambdaInvoker;
+        this.workerFunctionName = workerFunctionName;
+    }
+
+    /**
+     * @param {Object} params
+     * @param {string} params.migrationName - Migration to resolve
+     * @param {'applied'|'rolled-back'} [params.action] - Resolution mode
+     * @param {string} [params.stage] - Deployment stage
+     * @returns {Promise<Object>} Worker result body
+     */
+    async execute({ migrationName, action = 'applied', stage }) {
+        const dbType = process.env.DB_TYPE || 'postgresql';
+
+        console.log(
+            `Invoking worker Lambda to resolve migration "${migrationName}" as ${action}: ${this.workerFunctionName}`
+        );
+
+        return this.lambdaInvoker.invoke(this.workerFunctionName, {
+            action: 'resolve',
+            migrationName,
+            resolveAction: action,
+            dbType,
+            stage,
+        });
+    }
+}
+
+module.exports = { ResolveMigrationViaWorkerUseCase };

package/database/utils/prisma-runner.js

@@ -405,14 +405,25 @@ async function runPrismaMigrateResolve(migrationName, action = 'applied', verbos
             const [executable, ...executableArgs] = prismaBin.split(' ');
             const fullArgs = [...executableArgs, ...args];
 
+            let stdout = '';
+            let stderr = '';
             const proc = spawn(executable, fullArgs, {
-                stdio: 'inherit',
+                stdio: ['inherit', 'pipe', 'pipe'],
                 env: {
                     ...process.env,
                     PRISMA_HIDE_UPDATE_MESSAGE: '1'
                 }
             });
 
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+                if (verbose) process.stdout.write(data);
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+                if (verbose) process.stderr.write(data);
+            });
+
             proc.on('error', (error) => {
                 resolve({
                     success: false,
@@ -427,9 +438,12 @@ async function runPrismaMigrateResolve(migrationName, action = 'applied', verbos
                         output: `Migration ${migrationName} marked as ${action}`
                     });
                 } else {
+                    const detail = (stderr || stdout).trim();
                     resolve({
                         success: false,
-                        error: `Resolve process exited with code ${code}`
+                        error: detail
+                            ? `Prisma migrate resolve failed (exit ${code}): ${detail}`
+                            : `Resolve process exited with code ${code}`
                     });
                 }
             });

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/handlers/routers/db-migration.js

@@ -31,10 +31,16 @@ const {
     ValidationError: GetValidationError,
     NotFoundError,
 } = require('../../database/use-cases/get-migration-status-use-case');
-const { LambdaInvoker } = require('../../database/adapters/lambda-invoker');
+const {
+    LambdaInvoker,
+    LambdaInvocationError,
+} = require('../../database/adapters/lambda-invoker');
 const {
     GetDatabaseStateViaWorkerUseCase,
 } = require('../../database/use-cases/get-database-state-via-worker-use-case');
+const {
+    ResolveMigrationViaWorkerUseCase,
+} = require('../../database/use-cases/resolve-migration-via-worker-use-case');
 
 const router = Router();
 
@@ -58,6 +64,10 @@ const getDatabaseStateUseCase = new GetDatabaseStateViaWorkerUseCase({
     lambdaInvoker,
     workerFunctionName,
 });
+const resolveMigrationUseCase = new ResolveMigrationViaWorkerUseCase({
+    lambdaInvoker,
+    workerFunctionName,
+});
 
 // Apply admin API key validation to all routes (shared middleware)
 router.use(validateAdminApiKey);
@@ -255,6 +265,13 @@ router.post(
             });
         }
 
+        if (!/^\d{14}_[a-z0-9_]+$/i.test(migrationName)) {
+            return res.status(400).json({
+                success: false,
+                error: 'migrationName is not a valid migration identifier'
+            });
+        }
+
         if (!['applied', 'rolled-back'].includes(action)) {
             return res.status(400).json({
                 success: false,
@@ -262,30 +279,31 @@ router.post(
             });
         }
 
-        try {
-            // Import prismaRunner here to avoid circular dependencies
-            const prismaRunner = require('../../database/utils/prisma-runner');
-
-            const result = await prismaRunner.runPrismaMigrateResolve(migrationName, action, true);
+        const stage = req.body.stage || process.env.STAGE || 'production';
 
-            if (!result.success) {
-                return res.status(500).json({
-                    success: false,
-                    error: `Failed to resolve migration: ${result.error}`
-                });
-            }
-
-            res.status(200).json({
-                success: true,
-                message: `Migration ${migrationName} marked as ${action}`,
+        try {
+            const result = await resolveMigrationUseCase.execute({
                 migrationName,
-                action
+                action,
+                stage,
             });
+
+            res.status(200).json(result);
         } catch (error) {
             console.error('Migration resolve failed:', error);
+            if (
+                error instanceof LambdaInvocationError &&
+                error.statusCode === 400
+            ) {
+                return res.status(400).json({
+                    success: false,
+                    error: error.message,
+                });
+            }
             return res.status(500).json({
                 success: false,
-                error: error.message
+                error: 'Failed to resolve migration',
+                details: error.message,
             });
         }
     })

package/handlers/workers/db-migration.js

@@ -188,6 +188,81 @@ exports.handler = async (event, context) => {
         }
     }
 
+    if (action === 'resolve') {
+        const { migrationName, resolveAction = 'applied' } = event;
+        console.log(`\n========================================`);
+        console.log(
+            `Action: resolve (migration=${migrationName}, mode=${resolveAction})`
+        );
+        console.log(`========================================`);
+
+        if (!migrationName) {
+            return {
+                statusCode: 400,
+                body: { success: false, error: 'migrationName is required' },
+            };
+        }
+        if (!/^\d{14}_[a-z0-9_]+$/i.test(migrationName)) {
+            return {
+                statusCode: 400,
+                body: {
+                    success: false,
+                    error: 'migrationName is not a valid migration identifier',
+                },
+            };
+        }
+        if (!['applied', 'rolled-back'].includes(resolveAction)) {
+            return {
+                statusCode: 400,
+                body: {
+                    success: false,
+                    error: 'resolveAction must be "applied" or "rolled-back"',
+                },
+            };
+        }
+        if (dbType !== 'postgresql') {
+            return {
+                statusCode: 400,
+                body: {
+                    success: false,
+                    error: `Migration resolve is only supported for postgresql, not "${dbType}"`,
+                },
+            };
+        }
+
+        try {
+            const result = await prismaRunner.runPrismaMigrateResolve(
+                migrationName,
+                resolveAction,
+                true
+            );
+            if (!result.success) {
+                return {
+                    statusCode: 500,
+                    body: {
+                        success: false,
+                        error: sanitizeError(result.error),
+                    },
+                };
+            }
+            return {
+                statusCode: 200,
+                body: {
+                    success: true,
+                    message: `Migration ${migrationName} marked as ${resolveAction}`,
+                    migrationName,
+                    action: resolveAction,
+                },
+            };
+        } catch (error) {
+            console.error('❌ Migration resolve failed:', error.message);
+            return {
+                statusCode: 500,
+                body: { success: false, error: sanitizeError(error.message) },
+            };
+        }
+    }
+
     // Otherwise, handle migration (existing code)
     console.log(`\n========================================`);
     console.log(`Action: migrate (migrationId=${migrationId || 'new'})`);

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/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
      *