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

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/package.json

@@ -1,13 +1,15 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0-next.103",
+    "version": "2.0.0-next.105",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
         "@aws-sdk/client-lambda": "^3.714.0",
+        "@aws-sdk/client-s3": "^3.588.0",
         "@aws-sdk/client-sqs": "^3.588.0",
         "@aws-sdk/client-ssm": "^3.588.0",
+        "@aws-sdk/s3-request-presigner": "^3.588.0",
         "@hapi/boom": "^10.0.1",
         "@opentelemetry/api": "^1.9.1",
         "@opentelemetry/context-async-hooks": "^2.9.0",
@@ -46,9 +48,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0-next.103",
-        "@friggframework/prettier-config": "2.0.0-next.103",
-        "@friggframework/test": "2.0.0-next.103",
+        "@friggframework/eslint-config": "2.0.0-next.105",
+        "@friggframework/prettier-config": "2.0.0-next.105",
+        "@friggframework/test": "2.0.0-next.105",
         "@prisma/client": "^6.19.3",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -88,5 +90,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "9fc434b0c6e1323bd16be165d311b6880a23de12"
+    "gitHead": "d200bd6b1385a33736b67f48e3aa5ac3f5e167c8"
 }

package/reporting/README.md

@@ -1,27 +1,94 @@
 # Reporting
 
-Read-only, deployment-wide reporting endpoints for `@friggframework/core`.
-Gated by a dedicated reporting API key — **not** the per-user auth used by the
-rest of the Management API.
+Deployment-wide reports for `@friggframework/core`, modelled as **admin
+operations** (ADR-010) — a sibling of the Admin Script Runner (ADR-005) on the
+same primitives: one registry, the shared admin API key, sync/async execution,
+the isolated admin execution store, and EventBridge scheduling.
+
+A report is a definition (`ReportBase`) whose output is its payload. **Core
+ships built-in reports; adopters register their own** — both are discovered,
+listed, and executed through the same runner. This package provides `ReportBase`,
+the built-in reports, and `createReportCommands()`. The HTTP router, runner, and
+executor live in `@friggframework/admin-scripts`; the infrastructure (queue,
+executor Lambda, artifact bucket, scheduler) is generated by the devtools
+`AdminScriptBuilder`.
+
+## Registering reports
+
+```js
+// app definition — same shape as adminScripts
+const Definition = {
+  name: 'my-app',
+  integrations: [HubSpotIntegration, SalesforceIntegration],
+  reports: [ConnectedAccountsActivity],            // adopter-defined
+  admin: { includeBuiltinReports: true },          // + core built-ins (integrations, ...)
+};
+```
+
+A report extends `ReportBase` and reads only through the injected admin command
+bundle (`frigg` / `this.context.commands`), never a repository directly:
+
+```js
+const { ReportBase } = require('@friggframework/core');
+
+class ConnectedAccountsActivity extends ReportBase {
+  static Definition = {
+    name: 'connected-accounts-activity',
+    version: '1.0.0',
+    runModes: ['snapshot', 'recorded', 'live'],    // first is the default
+    inputSchema: { type: 'object', properties: {
+      windowDays: { type: 'integer', enum: [30, 60, 90], default: 30 } } },
+    output: { format: 'json' },                    // 'csv'|'pdf'|'zip' → artifact storage
+    schedule: { enabled: true, cron: 'cron(0 6 * * ? *)', mode: 'snapshot' }, // default mode only; activate via PUT
+  };
+
+  async execute(frigg, params) {
+    const since = daysAgo(params.windowDays ?? 30);
+    const byType = await frigg.credentials.countActiveByType({ since });
+    return { windowDays: params.windowDays ?? 30, byType };
+  }
+}
+```
 
 ## Auth
 
-Send the reporting key in the `x-frigg-reporting-api-key` header. It is validated
-against the `REPORTING_API_KEY` environment variable. Missing or wrong key → `401`.
+All report endpoints use the **shared admin API key** (ADR-005): the
+`x-frigg-admin-api-key` header, validated against `ADMIN_API_KEY`. The dedicated
+reporting key (`x-frigg-reporting-api-key` / `REPORTING_API_KEY`) is **retired**.
+
+## Run modes
+
+Each invocation picks a mode; persistence follows from it. All three run through
+the one runner and the isolated admin execution store (`AdminScriptExecution`,
+`type: 'REPORT'` — no user/integration FK, so a user-scoped query can never
+return a report record).
+
+| Mode | Persists | Use it for |
+| --- | --- | --- |
+| `live` | nothing — computes and returns inline | cheap, always-fresh queries |
+| `recorded` | an execution record (input + results + logs) | audit trail, async polling, expensive scans |
+| `snapshot` | a recorded run tagged into a named series | trends over time |
+
+Non-JSON `output.format` (`csv`/`pdf`/`zip`) is written to artifact storage (S3,
+private + signed URL) instead of inline; JSON stays inline.
 
 ## Endpoints
 
 | Method | Path | Description |
 | --- | --- | --- |
-| `GET` | `/api/v2/reports` | Index of available reports. |
-| `GET` | `/api/v2/reports/integrations` | Integrations report (see below). |
+| `GET` | `/api/v2/reports` | List registered report definitions. |
+| `GET` | `/api/v2/reports/:name` | Report definition detail (run modes, input schema, schedule). |
+| `POST` | `/api/v2/reports/:name/run` | Run `{ mode, params }`. `live` → `200` inline; `recorded`/`snapshot` → `202 { executionId }` (queued). |
+| `GET` | `/api/v2/reports/:name/snapshots?from=&to=` | A report's snapshot series (trend); each point carries a signed `artifactUrl` when the run produced a non-JSON artifact. |
+| `GET` | `/api/v2/reports/executions/:id` | Fetch one report execution (guarded to `type: 'REPORT'`); a stored artifact is returned as a signed `results.artifactUrl`. |
+| `GET`/`PUT`/`DELETE` | `/api/v2/reports/:name/schedule` | Manage a report's recurring schedule. |
+| `GET` | `/api/v2/reports/integrations` | Deprecated back-compat for PR #607 — runs the built-in `integrations` report in `live` mode and returns its payload directly. Prefer `POST /:name/run`. |
 
-### `GET /api/v2/reports/integrations`
+## Built-in: `integrations`
 
-Optional query params (all strings): `status` (an `IntegrationStatus`), `type`
-(`config.type` slug), `userId`.
-
-## Response shape
+Integrations by status and type, with per-type usage columns. Input query params
+(all strings): `status` (an `IntegrationStatus`), `type` (`config.type` slug),
+`userId`. Response shape (`schemaVersion: 1`):
 
 ```jsonc
 {
@@ -37,7 +104,8 @@ Optional query params (all strings): `status` (an `IntegrationStatus`), `type`
         "type": "hubspot",
         "label": "HubSpot CRM",
         "total": 5,
-        "byStatus": { "ENABLED": 4, "ERROR": 1, "NEEDS_CONFIG": 0, "PROCESSING": 0, "DISABLED": 0 }
+        "byStatus": { "ENABLED": 4, "ERROR": 1, "NEEDS_CONFIG": 0, "PROCESSING": 0, "DISABLED": 0 },
+        "usage": { "records.synced": 4200, "webhooks.received": 118 }
       }
     ],
     "typeLabels": { "hubspot": "HubSpot CRM" },
@@ -46,7 +114,7 @@ Optional query params (all strings): `status` (an `IntegrationStatus`), `type`
 }
 ```
 
-## Field reference
+### Field reference
 
 - `schemaVersion` — contract version; branch on it. Additive changes do **not** bump it.
 - `filters` — echoes the applied filters (nulls when omitted).
@@ -54,40 +122,33 @@ Optional query params (all strings): `status` (an `IntegrationStatus`), `type`
 - `metrics.byStatus` — counts keyed by `IntegrationStatus` value.
 - `metrics.byType[]` — per `type` breakdown: `{ type, label, total, byStatus, usage? }`.
   - `type` — the `config.type` slug. Integrations with no type bucket as `"unknown"`.
-  - `usage` — **additive** (ADR-011): present only when the deployment has the
-    usage store configured. A map of canonical counter → total for that type,
-    e.g. `{ "records.synced": 4200, "webhooks.received": 118, "api.requests": 9004 }`
-    (`0` when a type has no data). Read only from the Frigg usage store, never an
-    external APM; a usage-store read failure never fails the structural report.
-    Populated by the counters an integration opts into via `Definition.usage` —
-    see [`../telemetry/README.md`](../telemetry/README.md).
-  - `label` — human-readable name from the integration class's
-    `Definition.display.label`. Falls back to the `type` slug when no registered
-    class supplies a label (e.g. an integration that was removed, or run on an
-    older app that doesn't register it). Additive — `type` is unchanged.
-- `metrics.typeLabels` — map of `type` slug → human-readable label, so callers can
-  label `integrations[].type` rows without bloating each row. Contains only types
-  whose registered class supplies a non-default `display.label` (classes still
-  carrying the IntegrationBase default `'Integration Name'` are excluded).
-- `metrics.integrations[]` — lightweight per-integration rows (`id`, `type`,
-  `status`, `userId`, `version`, `moduleCount`, `errorCount`, `mappedRecordCount`,
-  `createdAt`, `updatedAt`). These rows carry `type` only — resolve display names
-  via `metrics.typeLabels`.
-
-## How labels are sourced
-
-`createReportingRouter()` loads the app's registered integration classes via
-`loadAppDefinition()` and builds a `{ slug → label }` map from each class's
-`Definition.display.label`. Loading is wrapped in try/catch, so reporting still
-works (labels fall back to slugs) if the app definition can't be loaded. The
-`ListIntegrationsReport` use case stays storage-agnostic — it just reads the
-injected `typeLabels` map, so all database adapters (PostgreSQL, MongoDB,
-DocumentDB) get labels with zero adapter changes.
+  - `usage` — **additive** (ADR-011): present only when the deployment has the usage
+    store configured. A map of canonical counter → total for that type (`0` when a
+    type has no data). Read only from the Frigg usage store; a usage-store read
+    failure never fails the structural report. Populated by the counters an
+    integration opts into via `Definition.usage` — see [`../telemetry/README.md`](../telemetry/README.md).
+  - `label` — human-readable name from the integration class's `Definition.display.label`,
+    falling back to the `type` slug when no registered class supplies one.
+- `metrics.typeLabels` — map of `type` slug → label, so callers label
+  `integrations[].type` rows without bloating each row.
+- `metrics.integrations[]` — lightweight per-integration rows (`id`, `type`, `status`,
+  `userId`, `version`, `moduleCount`, `errorCount`, `mappedRecordCount`, `createdAt`,
+  `updatedAt`). Resolve display names via `metrics.typeLabels`.
+
+The built-in report reads its data through the admin command bundle
+(`frigg.integrations.listForReport`, `frigg.integrationMappings.countByIntegrationIds`,
+`frigg.usage.getTotalsByDimension`) — the retired reporting repository triad's
+logic now lives in the canonical integration/mapping repositories, so all
+database adapters (PostgreSQL, MongoDB, DocumentDB) are served through one path.
 
 ## Caveats
 
-- The response is sensitive (exposes integration types, counts, user IDs, versions).
-  Treat the reporting key as an admin secret.
-- Read-only — no mutation endpoints.
-- Labels only appear once the deployment runs a `@friggframework/core` version that
-  includes this field and the app registers the integration classes.
+- Report output is sensitive (integration types, counts, user IDs, versions).
+  Treat the admin API key as an admin secret.
+- The `integrations` back-compat alias is transitional; migrate to
+  `POST /api/v2/reports/integrations/run { "mode": "live" }`.
+- Labels only appear once the app registers the integration classes.
+- A `schedule` block in a report's Definition only supplies the default scheduled
+  **mode**. It does not create a recurring trigger on its own — activate the
+  schedule with `PUT /api/v2/reports/:name/schedule`; the DB schedule
+  (`ScriptSchedule`) is the single source of truth.

package/reporting/builtin-reports.js

@@ -0,0 +1,6 @@
+const { IntegrationsReport } = require('./reports/integrations-report');
+
+// Registered by the admin-scripts bootstrap when the app definition sets `admin.includeBuiltinReports`.
+const BUILTIN_REPORTS = [IntegrationsReport];
+
+module.exports = { BUILTIN_REPORTS };

package/reporting/index.js

@@ -1,17 +1,13 @@
-const { createReportingRouter } = require('./reporting-router');
+const { ReportBase } = require('./report-base');
+const { IntegrationsReport } = require('./reports/integrations-report');
+const { BUILTIN_REPORTS } = require('./builtin-reports');
 const {
-    createReportingRepository,
-    ReportingRepositoryMongo,
-    ReportingRepositoryPostgres,
-    ReportingRepositoryDocumentDB,
-} = require('./repositories/reporting-repository-factory');
-const { ListIntegrationsReport } = require('./use-cases');
+    createReportCommands,
+} = require('../application/commands/report-commands');
 
 module.exports = {
-    createReportingRouter,
-    createReportingRepository,
-    ReportingRepositoryMongo,
-    ReportingRepositoryPostgres,
-    ReportingRepositoryDocumentDB,
-    ListIntegrationsReport,
+    ReportBase,
+    IntegrationsReport,
+    BUILTIN_REPORTS,
+    createReportCommands,
 };

package/reporting/report-base.js

@@ -0,0 +1,49 @@
+/**
+ * ReportBase — a report is an admin operation whose output is its payload.
+ *
+ * A report Definition declares:
+ *   - runModes: allowed modes; the first is the default.
+ *       'live'     — compute and return inline; persist nothing.
+ *       'recorded' — persist an execution record (input + results + logs).
+ *       'snapshot' — a recorded run tagged as a point in a named series.
+ *   - output.format: 'json' returns inline; 'csv'|'pdf'|'zip' go to artifact storage.
+ *   - schedule: optional recurring run via EventBridge.
+ *
+ * execute(frigg, params): `frigg` is the admin command bundle
+ * (=== this.context.commands); do data reads through it, never a repository.
+ */
+class ReportBase {
+    static Definition = {
+        name: 'Report Name',
+        version: '0.0.0',
+        description: 'What this report computes',
+        source: 'USER_DEFINED', // 'BUILTIN' | 'USER_DEFINED'
+
+        runModes: ['live', 'recorded', 'snapshot'],
+        inputSchema: null,
+        outputSchema: null,
+        output: { format: 'json' },
+        schedule: { enabled: false, cron: null, mode: 'snapshot' },
+
+        config: {
+            timeout: 300000,
+        },
+
+        display: {
+            category: 'reporting',
+            icon: null,
+        },
+    };
+
+    constructor(params = {}) {
+        this.context = params.context || null;
+        this.executionId = params.executionId || null;
+        this.integrationFactory = params.integrationFactory || null;
+    }
+
+    async execute(frigg, params) {
+        throw new Error('ReportBase.execute() must be implemented by subclass');
+    }
+}
+
+module.exports = { ReportBase };

package/reporting/{use-cases/list-integrations-report.js → reports/integrations-report.js}

@@ -1,11 +1,11 @@
-const Boom = require('@hapi/boom');
+const { ReportBase } = require('../report-base');
 const { CANONICAL_COUNTERS } = require('../../telemetry/canonical-counters');
+const { loadAppDefinition } = require('../../handlers/app-definition-loader');
 
 const SCHEMA_VERSION = 1;
 const SERVICE = 'frigg-core-api';
 
-// Seeded so every known status appears (even at 0); unknown values added to
-// the schema later are still counted dynamically.
+// Seeded so every known status appears in output even at count 0.
 const KNOWN_STATUSES = [
     'IN_CREATION',
     'ENABLED',
@@ -16,33 +16,37 @@ const KNOWN_STATUSES = [
     'DISABLED',
 ];
 
-class ListIntegrationsReport {
-    constructor({
-        reportingRepository,
-        usageRepository,
-        typeLabels = {},
-    } = {}) {
-        if (!reportingRepository) {
-            throw new Error('reportingRepository is required');
-        }
-        if (!usageRepository) {
-            throw new Error('usageRepository is required');
-        }
-        this.reportingRepository = reportingRepository;
-        this.usageRepository = usageRepository;
-        this.typeLabels = typeLabels;
-    }
+// IntegrationBase.Definition default — skip it so the slug is used instead.
+const PLACEHOLDER_DISPLAY_NAME = 'Integration Name';
+
+class IntegrationsReport extends ReportBase {
+    static Definition = {
+        name: 'integrations',
+        version: '1.0.0',
+        description: 'Integrations by status and type, with per-type usage counts',
+        source: 'BUILTIN',
+        runModes: ['live', 'recorded', 'snapshot'],
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                status: { type: 'string' },
+                type: { type: 'string' },
+                userId: { type: 'string' },
+            },
+        },
+        output: { format: 'json' },
+        schedule: { enabled: false, cron: null, mode: 'snapshot' },
+        display: { category: 'reporting', icon: null },
+    };
 
-    async execute(query = {}) {
-        const { status, type, userId } = this._validateQuery(query);
+    async execute(frigg, params = {}) {
+        const { status, type, userId } = this._validateQuery(params);
+        const typeLabels = buildTypeLabels();
 
-        const rows = await this.reportingRepository.findIntegrationsForReport({
-            status,
-            userId,
-        });
+        const rows = await frigg.integrations.listForReport({ status, userId });
 
-        // type lives in config.type (a JSON path not portably groupable across
-        // DBs), so it is filtered here rather than in the repository query.
+        // type lives in config.type, a JSON path not portably groupable across DBs, so filter here not in the query.
         const filtered =
             type === undefined
                 ? rows
@@ -50,7 +54,7 @@ class ListIntegrationsReport {
 
         const ids = filtered.map((row) => row.id);
         const mappingCounts = ids.length
-            ? await this.reportingRepository.countMappingsByIntegrationIds(ids)
+            ? await frigg.integrationMappings.countByIntegrationIds(ids)
             : new Map();
 
         const integrations = filtered.map((row) => ({
@@ -76,8 +80,7 @@ class ListIntegrationsReport {
             if (!byTypeMap.has(integration.type)) {
                 byTypeMap.set(integration.type, {
                     type: integration.type,
-                    label:
-                        this.typeLabels[integration.type] || integration.type,
+                    label: typeLabels[integration.type] || integration.type,
                     total: 0,
                     byStatus: emptyStatusCounts(),
                 });
@@ -87,7 +90,7 @@ class ListIntegrationsReport {
             bucket.byStatus[statusKey] = (bucket.byStatus[statusKey] ?? 0) + 1;
         }
 
-        await this._attachUsageColumns(byTypeMap);
+        await this._attachUsageColumns(byTypeMap, frigg);
 
         return {
             schemaVersion: SCHEMA_VERSION,
@@ -102,18 +105,18 @@ class ListIntegrationsReport {
                 total: integrations.length,
                 byStatus,
                 byType: Array.from(byTypeMap.values()),
-                typeLabels: { ...this.typeLabels },
+                typeLabels: { ...typeLabels },
                 integrations,
             },
         };
     }
 
-    async _attachUsageColumns(byTypeMap) {
+    async _attachUsageColumns(byTypeMap, frigg) {
         const metrics = Object.keys(CANONICAL_COUNTERS);
         try {
             const totalsByMetric = await Promise.all(
                 metrics.map(async (metric) => {
-                    const totals = await this.usageRepository.getTotalsByDimension({
+                    const totals = await frigg.usage.getTotalsByDimension({
                         metric,
                         groupBy: 'integrationType',
                     });
@@ -146,7 +149,7 @@ class ListIntegrationsReport {
                 value !== null &&
                 typeof value !== 'string'
             ) {
-                throw Boom.badRequest(
+                throw invalidInput(
                     `Invalid query parameter '${key}': expected a string`
                 );
             }
@@ -158,7 +161,7 @@ class ListIntegrationsReport {
             userId: normalize(userId),
         };
         if (normalized.status && !KNOWN_STATUSES.includes(normalized.status)) {
-            throw Boom.badRequest(
+            throw invalidInput(
                 `Invalid status '${
                     normalized.status
                 }'. Expected one of: ${KNOWN_STATUSES.join(', ')}`
@@ -168,6 +171,13 @@ class ListIntegrationsReport {
     }
 }
 
+// INVALID_INPUT keeps the report protocol-agnostic; the runner/router map it to a 400.
+function invalidInput(message) {
+    const error = new Error(message);
+    error.code = 'INVALID_INPUT';
+    return error;
+}
+
 function emptyStatusCounts() {
     return KNOWN_STATUSES.reduce((acc, status) => {
         acc[status] = 0;
@@ -186,4 +196,26 @@ function toIso(value) {
     return String(value);
 }
 
-module.exports = { ListIntegrationsReport, SCHEMA_VERSION };
+function buildTypeLabels() {
+    try {
+        const { integrations = [] } = loadAppDefinition();
+        const labels = {};
+        for (const IntegrationClass of integrations) {
+            const def = IntegrationClass?.Definition;
+            if (!def?.name) continue;
+            const label = def.display?.label;
+            if (label && label !== PLACEHOLDER_DISPLAY_NAME) {
+                labels[def.name] = label;
+            }
+        }
+        return labels;
+    } catch (error) {
+        console.error(
+            'Reporting: failed to load integration labels:',
+            error.message
+        );
+        return {};
+    }
+}
+
+module.exports = { IntegrationsReport, SCHEMA_VERSION };

package/handlers/routers/reporting.js

@@ -1,9 +0,0 @@
-const { createReportingRouter } = require('@friggframework/core');
-const { createAppHandler } = require('./../app-handler-helpers');
-
-const router = createReportingRouter();
-
-// true → eager-connect Prisma; the reporting endpoints read the DB.
-const handler = createAppHandler('HTTP Event: Reporting', router, true);
-
-module.exports = { handler, router };