@pipeline-builder/pipeline-data 4.1.15 → 4.1.17

package/lib/api/reporting/plugin-runtime.js

@@ -0,0 +1,106 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Per-plugin RUNTIME telemetry: how plugins behave when
+ * pipelines run them, as opposed to the plugin BUILD reports. Reads the
+ * `plugin_publisher/plugin_name/plugin_version` that event ingest stamps on
+ * ACTION events from the pipeline's step manifest.
+ *
+ * A "run" is one terminal ACTION event — SUCCEEDED or FAILED. Canceled,
+ * abandoned and superseded actions say nothing about the plugin and are left
+ * out of both the count and the rate.
+ *
+ * Two audiences:
+ *   - the org's own dashboard ({@link getPluginRuntime}): org-scoped (rollup
+ *     aware), grouped per plugin version;
+ *   - the ecosystem, service-to-service ({@link getPluginRuntimeAggregate},
+ *     {@link hasVerifiedPluginUse}): cross-org aggregates keyed on a listing's
+ *     `(publisher, name)`, feeding `plugin_stats` and the review "verified use"
+ *     badge. Never exposed to a user token — they read every org's events.
+ */
+import { sql } from 'drizzle-orm';
+import { orgScope, runReport } from './query-scope.js';
+import { schema } from '../../database/drizzle-schema.js';
+import { runWithTenantContext, withTenantTx } from '../../database/tenancy.js';
+import { drizzleRows } from '../crud-service.js';
+/** Window for the ecosystem aggregate (`plugin_stats.success_rate_30d`). */
+export const PLUGIN_RUNTIME_AGGREGATE_DAYS = 30;
+/** Window for review "verified use": a successful run in the last 90 days. */
+export const PLUGIN_VERIFIED_USE_DAYS = 90;
+/** The terminal-ACTION, plugin-attributed predicate every runtime read shares (alias `e`). */
+const pluginRuns = sql `e.event_type = 'ACTION' AND e.plugin_name IS NOT NULL
+          AND e.status IN ('SUCCEEDED', 'FAILED')`;
+/** `IS NULL` for an own-org (publisher-less) plugin, `=` otherwise. */
+function publisherPredicate(publisher) {
+    return publisher === null ? sql `e.plugin_publisher IS NULL` : sql `e.plugin_publisher = ${publisher}`;
+}
+/**
+ * Per plugin version: runs, success rate and duration (p50/p95) over
+ * `[from, to]` on `completed_at`, for the org (or its rollup subtree).
+ * Optional filters narrow to one plugin name / publisher (`null` = own-org
+ * plugins) / version.
+ */
+export async function getPluginRuntime(orgId, from, to, filter = {}, orgIds) {
+    const { pred, multi } = orgScope(orgId, orgIds);
+    const nameClause = filter.name !== undefined ? sql `AND e.plugin_name = ${filter.name}` : sql ``;
+    const publisherClause = filter.publisher !== undefined ? sql `AND ${publisherPredicate(filter.publisher)}` : sql ``;
+    const versionClause = filter.version !== undefined ? sql `AND e.plugin_version = ${filter.version}` : sql ``;
+    const exec = () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          e.plugin_publisher AS "pluginPublisher",
+          e.plugin_name AS "pluginName",
+          e.plugin_version AS "pluginVersion",
+          COUNT(*)::int AS runs,
+          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,
+          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,
+          ROUND(COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::numeric
+            / NULLIF(COUNT(*), 0) * 100, 1)::float AS "successPct",
+          PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY e.duration_ms)::int AS "p50Ms",
+          PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY e.duration_ms)::int AS "p95Ms",
+          MAX(e.completed_at)::text AS "lastRun"
+        FROM ${schema.pipelineEvent} e
+        WHERE e.org_id ${pred} AND ${pluginRuns}
+          AND e.completed_at >= ${from}::timestamptz AND e.completed_at <= ${to}::timestamptz
+          ${nameClause} ${publisherClause} ${versionClause}
+        GROUP BY e.plugin_publisher, e.plugin_name, e.plugin_version
+        ORDER BY runs DESC
+      `).then(r => drizzleRows(r.rows)));
+    const filterKey = `${filter.name ?? ''}:${filter.publisher === null ? '\u0000' : filter.publisher ?? ''}:${filter.version ?? ''}`;
+    return runReport(`${orgId}:plugin-runtime:${from}:${to}:${filterKey}`, multi, exec);
+}
+/**
+ * Ecosystem aggregate for one listing over the last 30 days, across EVERY org:
+ * runs, success rate (0–1; null with no runs) and how many distinct orgs ran it.
+ * Runs under system context — the caller is the plugin service computing
+ * `plugin_stats`, and `activeOrgCount30d` is only ever shown at ≥ 5.
+ */
+export async function getPluginRuntimeAggregate(publisher, name) {
+    const rows = await runWithTenantContext({ isSuperAdmin: true }, () => withTenantTx((tx) => tx.execute(sql `
+        SELECT
+          COUNT(*)::int AS "runs30d",
+          (COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::float
+            / NULLIF(COUNT(*), 0)) AS "successRate30d",
+          COUNT(DISTINCT e.org_id)::int AS "activeOrgCount30d"
+        FROM ${schema.pipelineEvent} e
+        WHERE ${pluginRuns} AND ${publisherPredicate(publisher)} AND e.plugin_name = ${name}
+          AND e.completed_at >= now() - make_interval(days => ${PLUGIN_RUNTIME_AGGREGATE_DAYS})
+      `).then(r => drizzleRows(r.rows))));
+    return rows[0] ?? { runs30d: 0, successRate30d: null, activeOrgCount30d: 0 };
+}
+/**
+ * Review "verified use": did `orgId` run `(publisher, name)` successfully
+ * in the last 90 days? Bounded by the org's event retention — a run older than
+ * the retention horizon has been swept and no longer counts.
+ */
+export async function hasVerifiedPluginUse(orgId, publisher, name) {
+    const rows = await runWithTenantContext({ orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.execute(sql `
+        SELECT EXISTS (
+          SELECT 1 FROM ${schema.pipelineEvent} e
+          WHERE e.org_id = ${orgId} AND ${pluginRuns} AND e.status = 'SUCCEEDED'
+            AND ${publisherPredicate(publisher)} AND e.plugin_name = ${name}
+            AND e.completed_at >= now() - make_interval(days => ${PLUGIN_VERIFIED_USE_DAYS})
+        ) AS "verified"
+      `).then(r => drizzleRows(r.rows))));
+    return rows[0]?.verified === true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-runtime.js","sourceRoot":"","sources":["../../../src/api/reporting/plugin-runtime.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,4EAA4E;AAC5E,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,CAAC;AAChD,8EAA8E;AAC9E,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,CAAC;AAE3C,8FAA8F;AAC9F,MAAM,UAAU,GAAG,GAAG,CAAA;kDAC4B,CAAC;AAEnD,uEAAuE;AACvE,SAAS,kBAAkB,CAAC,SAAwB;IAClD,OAAO,SAAS,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,CAAA,4BAA4B,CAAC,CAAC,CAAC,GAAG,CAAA,wBAAwB,SAAS,EAAE,CAAC;AACvG,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,KAAa,EACb,IAAY,EACZ,EAAU,EACV,MAAM,GAAwB,EAAE,EAChC,MAAiB;IAEjB,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAChD,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAA,uBAAuB,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,CAAA,EAAE,CAAC;IAC/F,MAAM,eAAe,GAAG,MAAM,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAA,OAAO,kBAAkB,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAA,EAAE,CAAC;IAClH,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,CAAA,0BAA0B,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,GAAG,CAAA,EAAE,CAAC;IAC3G,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;;;;;;;;eAazC,MAAM,CAAC,aAAa;yBACV,IAAI,QAAQ,UAAU;kCACb,IAAI,uCAAuC,EAAE;YACnE,UAAU,IAAI,eAAe,IAAI,aAAa;;;OAGnD,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAqB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC3D,MAAM,SAAS,GAAG,GAAG,MAAM,CAAC,IAAI,IAAI,EAAE,IAAI,MAAM,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,IAAI,EAAE,IAAI,MAAM,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC;IAClI,OAAO,SAAS,CAAC,GAAG,KAAK,mBAAmB,IAAI,IAAI,EAAE,IAAI,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AACtF,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,SAAiB,EAAE,IAAY;IAC7E,MAAM,IAAI,GAAG,MAAM,oBAAoB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;;;;;eAM5F,MAAM,CAAC,aAAa;gBACnB,UAAU,QAAQ,kBAAkB,CAAC,SAAS,CAAC,wBAAwB,IAAI;gEAC3B,6BAA6B;OACtF,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAyB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,cAAc,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;AAC/E,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,KAAa,EAAE,SAAiB,EAAE,IAAY;IACvF,MAAM,IAAI,GAAG,MAAM,oBAAoB,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAA;;0BAEzF,MAAM,CAAC,aAAa;6BACjB,KAAK,QAAQ,UAAU;kBAClC,kBAAkB,CAAC,SAAS,CAAC,wBAAwB,IAAI;kEACT,wBAAwB;;OAEnF,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAwB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/D,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,CAAC;AACpC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Per-plugin RUNTIME telemetry: how plugins behave when\n * pipelines run them, as opposed to the plugin BUILD reports. Reads the\n * `plugin_publisher/plugin_name/plugin_version` that event ingest stamps on\n * ACTION events from the pipeline's step manifest.\n *\n * A \"run\" is one terminal ACTION event — SUCCEEDED or FAILED. Canceled,\n * abandoned and superseded actions say nothing about the plugin and are left\n * out of both the count and the rate.\n *\n * Two audiences:\n *   - the org's own dashboard ({@link getPluginRuntime}): org-scoped (rollup\n *     aware), grouped per plugin version;\n *   - the ecosystem, service-to-service ({@link getPluginRuntimeAggregate},\n *     {@link hasVerifiedPluginUse}): cross-org aggregates keyed on a listing's\n *     `(publisher, name)`, feeding `plugin_stats` and the review \"verified use\"\n *     badge. Never exposed to a user token — they read every org's events.\n */\n\nimport { sql } from 'drizzle-orm';\nimport { orgScope, runReport } from './query-scope.js';\nimport type { PluginRuntimeAggregate, PluginRuntimeFilter, PluginRuntimeStats } from './types.js';\nimport { schema } from '../../database/drizzle-schema.js';\nimport { runWithTenantContext, withTenantTx } from '../../database/tenancy.js';\nimport { drizzleRows } from '../crud-service.js';\n\n/** Window for the ecosystem aggregate (`plugin_stats.success_rate_30d`). */\nexport const PLUGIN_RUNTIME_AGGREGATE_DAYS = 30;\n/** Window for review \"verified use\": a successful run in the last 90 days. */\nexport const PLUGIN_VERIFIED_USE_DAYS = 90;\n\n/** The terminal-ACTION, plugin-attributed predicate every runtime read shares (alias `e`). */\nconst pluginRuns = sql`e.event_type = 'ACTION' AND e.plugin_name IS NOT NULL\n          AND e.status IN ('SUCCEEDED', 'FAILED')`;\n\n/** `IS NULL` for an own-org (publisher-less) plugin, `=` otherwise. */\nfunction publisherPredicate(publisher: string | null) {\n  return publisher === null ? sql`e.plugin_publisher IS NULL` : sql`e.plugin_publisher = ${publisher}`;\n}\n\n/**\n * Per plugin version: runs, success rate and duration (p50/p95) over\n * `[from, to]` on `completed_at`, for the org (or its rollup subtree).\n * Optional filters narrow to one plugin name / publisher (`null` = own-org\n * plugins) / version.\n */\nexport async function getPluginRuntime(\n  orgId: string,\n  from: string,\n  to: string,\n  filter: PluginRuntimeFilter = {},\n  orgIds?: string[],\n): Promise<PluginRuntimeStats[]> {\n  const { pred, multi } = orgScope(orgId, orgIds);\n  const nameClause = filter.name !== undefined ? sql`AND e.plugin_name = ${filter.name}` : sql``;\n  const publisherClause = filter.publisher !== undefined ? sql`AND ${publisherPredicate(filter.publisher)}` : sql``;\n  const versionClause = filter.version !== undefined ? sql`AND e.plugin_version = ${filter.version}` : sql``;\n  const exec = () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          e.plugin_publisher AS \"pluginPublisher\",\n          e.plugin_name AS \"pluginName\",\n          e.plugin_version AS \"pluginVersion\",\n          COUNT(*)::int AS runs,\n          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS \"successPct\",\n          PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY e.duration_ms)::int AS \"p50Ms\",\n          PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY e.duration_ms)::int AS \"p95Ms\",\n          MAX(e.completed_at)::text AS \"lastRun\"\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id ${pred} AND ${pluginRuns}\n          AND e.completed_at >= ${from}::timestamptz AND e.completed_at <= ${to}::timestamptz\n          ${nameClause} ${publisherClause} ${versionClause}\n        GROUP BY e.plugin_publisher, e.plugin_name, e.plugin_version\n        ORDER BY runs DESC\n      `).then(r => drizzleRows<PluginRuntimeStats>(r.rows)));\n  const filterKey = `${filter.name ?? ''}:${filter.publisher === null ? '\\u0000' : filter.publisher ?? ''}:${filter.version ?? ''}`;\n  return runReport(`${orgId}:plugin-runtime:${from}:${to}:${filterKey}`, multi, exec);\n}\n\n/**\n * Ecosystem aggregate for one listing over the last 30 days, across EVERY org:\n * runs, success rate (0–1; null with no runs) and how many distinct orgs ran it.\n * Runs under system context — the caller is the plugin service computing\n * `plugin_stats`, and `activeOrgCount30d` is only ever shown at ≥ 5.\n */\nexport async function getPluginRuntimeAggregate(publisher: string, name: string): Promise<PluginRuntimeAggregate> {\n  const rows = await runWithTenantContext({ isSuperAdmin: true }, () => withTenantTx((tx) => tx.execute(sql`\n        SELECT\n          COUNT(*)::int AS \"runs30d\",\n          (COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::float\n            / NULLIF(COUNT(*), 0)) AS \"successRate30d\",\n          COUNT(DISTINCT e.org_id)::int AS \"activeOrgCount30d\"\n        FROM ${schema.pipelineEvent} e\n        WHERE ${pluginRuns} AND ${publisherPredicate(publisher)} AND e.plugin_name = ${name}\n          AND e.completed_at >= now() - make_interval(days => ${PLUGIN_RUNTIME_AGGREGATE_DAYS})\n      `).then(r => drizzleRows<PluginRuntimeAggregate>(r.rows))));\n  return rows[0] ?? { runs30d: 0, successRate30d: null, activeOrgCount30d: 0 };\n}\n\n/**\n * Review \"verified use\": did `orgId` run `(publisher, name)` successfully\n * in the last 90 days? Bounded by the org's event retention — a run older than\n * the retention horizon has been swept and no longer counts.\n */\nexport async function hasVerifiedPluginUse(orgId: string, publisher: string, name: string): Promise<boolean> {\n  const rows = await runWithTenantContext({ orgId, isSuperAdmin: false }, () => withTenantTx((tx) => tx.execute(sql`\n        SELECT EXISTS (\n          SELECT 1 FROM ${schema.pipelineEvent} e\n          WHERE e.org_id = ${orgId} AND ${pluginRuns} AND e.status = 'SUCCEEDED'\n            AND ${publisherPredicate(publisher)} AND e.plugin_name = ${name}\n            AND e.completed_at >= now() - make_interval(days => ${PLUGIN_VERIFIED_USE_DAYS})\n        ) AS \"verified\"\n      `).then(r => drizzleRows<{ verified: boolean }>(r.rows))));\n  return rows[0]?.verified === true;\n}\n"]}

package/lib/api/reporting/query-scope.d.ts

@@ -1,3 +1,4 @@
+import { type SQL } from 'drizzle-orm';
 /**
  * Build the org-scope predicate for a report query. With `orgIds` (the
  * org → team rollup — a parent's `[self, ...descendants]`) it becomes an
@@ -7,7 +8,7 @@
  * cache key.
  */
 export declare function orgScope(orgId: string, orgIds?: string[]): {
-    pred: import("drizzle-orm").SQL<unknown>;
+    pred: SQL<unknown>;
     multi: boolean;
 };
 /**
@@ -18,4 +19,9 @@ export declare function orgScope(orgId: string, orgIds?: string[]): {
  * has no org tree), so caching them would serve stale aggregates. Always fresh.
  */
 export declare function runReport<T>(cacheKey: string, multi: boolean, exec: () => Promise<T>): Promise<T>;
-/** 1.1 Execution count per pipeline with status breakdown. */
+/**
+ * One org-scoped report read: build the SQL from the org-scope predicate, run it
+ * in the tenant transaction and return the rows, through {@link runReport}'s
+ * cache/rollup policy. `key` is the cache key below the org.
+ */
+export declare function report<T>(key: string, orgId: string, orgIds: string[] | undefined, query: (pred: SQL) => SQL): Promise<T[]>;

package/lib/api/reporting/query-scope.js

@@ -3,15 +3,15 @@
 /**
  * Tenancy scoping and cache/context policy for reporting reads.
  *
- * These were private methods on ReportingService. They hold no instance state —
- * only the module-level logger and timeseries cache — so they are plain
- * functions here, which is what lets the per-domain query modules (dora.ts)
- * use the identical scoping rules without reaching back into the class.
+ * Plain functions (no instance state — only the module-level logger and
+ * timeseries cache) so the per-domain query modules (dora.ts) use the identical
+ * scoping rules as ReportingService.
  */
 import { createLogger } from '@pipeline-builder/api-core';
 import { sql } from 'drizzle-orm';
 import { timeseriesCache } from './caches.js';
-import { runWithTenantContext } from '../../database/tenancy.js';
+import { resultRows } from '../../database/pg-result.js';
+import { runWithTenantContext, withTenantTx } from '../../database/tenancy.js';
 const logger = createLogger('reporting-service');
 /**
  * Build the org-scope predicate for a report query. With `orgIds` (the
@@ -58,5 +58,14 @@ export function runReport(cacheKey, multi, exec) {
         ? runWithTenantContext({ isSuperAdmin: true }, exec)
         : timeseriesCache.getOrSet(cacheKey, exec);
 }
-/** 1.1 Execution count per pipeline with status breakdown. */
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * One org-scoped report read: build the SQL from the org-scope predicate, run it
+ * in the tenant transaction and return the rows, through {@link runReport}'s
+ * cache/rollup policy. `key` is the cache key below the org.
+ */
+export function report(key, orgId, orgIds, query) {
+    const { pred, multi } = orgScope(orgId, orgIds);
+    const exec = () => withTenantTx((tx) => tx.execute(query(pred))).then((r) => resultRows(r));
+    return runReport(`${orgId}:${key}`, multi, exec);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/reporting/retention.d.ts

@@ -1,9 +1,5 @@
 /**
- * Retention windows for reporting data: env-configurable, clamped to a sane
- * range, and overridable per-org by the settings row.
- */
-/**
- * Reporting retention windows (Phase 7). Records in `pipeline_events`,
+ * Reporting retention windows. Records in `pipeline_events`,
  * `deployment_outcomes`, and `incidents` grow unbounded without a sweep, so a
  * split, per-org retention purge (see {@link ReportingService.purgeExpiredReportingData})
  * hard-deletes rows older than these windows, by `created_at`:
@@ -17,22 +13,20 @@
  * `ingest_health` and `dora_settings` are never purged. Env-overridable globals;
  * a per-org override in `dora_settings` wins (see {@link resolveEventRetentionDays}).
  */
-export declare const RETENTION_MIN_DAYS = 1;
-export declare const RETENTION_MAX_DAYS = 730;
 /** Parse a positive-int env day-count, clamped to [MIN, MAX], else `fallback`. */
 export declare function retentionEnvDays(name: string, fallback: number): number;
 export declare const REPORTING_EVENT_RETENTION_DAYS: number;
 export declare const REPORTING_DORA_RETENTION_DAYS: number;
 /** Effective standard-event retention (days): a valid per-org override wins,
  *  else the global env default. Shared by the sweep + the settings surface so
- *  they can't drift. The `-1` unlimited sentinel (Phase 8) passes straight
+ *  they can't drift. The `-1` unlimited sentinel passes straight
  *  through — the sweep reads it as "keep forever, skip this org's standard
  *  events". A positive override clamps to [1, RETENTION_MAX_DAYS]; a `null`, a
  *  non-integer, or any other out-of-range value (e.g. 0, -2) falls back to the
  *  env default. */
 export declare function resolveEventRetentionDays(override?: number | null): number;
 /** Effective DORA-source retention (days): a valid per-org override wins, else
- *  the global env default. The `-1` unlimited sentinel (Phase 8) passes straight
+ *  the global env default. The `-1` unlimited sentinel passes straight
  *  through — the sweep reads it as "keep forever, skip this org's DORA-source
  *  windows". A positive override clamps to [1, RETENTION_MAX_DAYS]; a `null`, a
  *  non-integer, or any other out-of-range value (e.g. 0, -2) falls back to the
@@ -41,4 +35,4 @@ export declare function resolveDoraRetentionDays(override?: number | null): numb
 /** The cutoff instant for a retention window: rows with `created_at` strictly
  *  before this (`< cutoff`) are expired. Deterministic for a fixed `now`. */
 export declare function retentionCutoff(now: Date, days: number): Date;
-/** Per-org retention override row (Phase 7). Both nullable ⇒ global defaults. */
+/** Per-org retention override row. Both nullable ⇒ global defaults. */

package/lib/api/reporting/retention.js

@@ -4,8 +4,9 @@
  * Retention windows for reporting data: env-configurable, clamped to a sane
  * range, and overridable per-org by the settings row.
  */
+import { envInt, RETENTION_MAX_DAYS, RETENTION_MIN_DAYS } from '@pipeline-builder/api-core';
 /**
- * Reporting retention windows (Phase 7). Records in `pipeline_events`,
+ * Reporting retention windows. Records in `pipeline_events`,
  * `deployment_outcomes`, and `incidents` grow unbounded without a sweep, so a
  * split, per-org retention purge (see {@link ReportingService.purgeExpiredReportingData})
  * hard-deletes rows older than these windows, by `created_at`:
@@ -19,20 +20,16 @@
  * `ingest_health` and `dora_settings` are never purged. Env-overridable globals;
  * a per-org override in `dora_settings` wins (see {@link resolveEventRetentionDays}).
  */
-export const RETENTION_MIN_DAYS = 1;
-export const RETENTION_MAX_DAYS = 730;
 /** Parse a positive-int env day-count, clamped to [MIN, MAX], else `fallback`. */
 export function retentionEnvDays(name, fallback) {
-    const raw = Number(process.env[name]);
-    if (!Number.isFinite(raw) || !Number.isInteger(raw) || raw < RETENTION_MIN_DAYS)
-        return fallback;
-    return Math.min(raw, RETENTION_MAX_DAYS);
+    const days = envInt(name, fallback);
+    return days < RETENTION_MIN_DAYS ? fallback : Math.min(days, RETENTION_MAX_DAYS);
 }
 export const REPORTING_EVENT_RETENTION_DAYS = retentionEnvDays('REPORTING_EVENT_RETENTION_DAYS', 30);
 export const REPORTING_DORA_RETENTION_DAYS = retentionEnvDays('REPORTING_DORA_RETENTION_DAYS', 180);
 /** Effective standard-event retention (days): a valid per-org override wins,
  *  else the global env default. Shared by the sweep + the settings surface so
- *  they can't drift. The `-1` unlimited sentinel (Phase 8) passes straight
+ *  they can't drift. The `-1` unlimited sentinel passes straight
  *  through — the sweep reads it as "keep forever, skip this org's standard
  *  events". A positive override clamps to [1, RETENTION_MAX_DAYS]; a `null`, a
  *  non-integer, or any other out-of-range value (e.g. 0, -2) falls back to the
@@ -44,7 +41,7 @@ export function resolveEventRetentionDays(override) {
         ? Math.min(override, RETENTION_MAX_DAYS) : REPORTING_EVENT_RETENTION_DAYS;
 }
 /** Effective DORA-source retention (days): a valid per-org override wins, else
- *  the global env default. The `-1` unlimited sentinel (Phase 8) passes straight
+ *  the global env default. The `-1` unlimited sentinel passes straight
  *  through — the sweep reads it as "keep forever, skip this org's DORA-source
  *  windows". A positive override clamps to [1, RETENTION_MAX_DAYS]; a `null`, a
  *  non-integer, or any other out-of-range value (e.g. 0, -2) falls back to the
@@ -60,5 +57,5 @@ export function resolveDoraRetentionDays(override) {
 export function retentionCutoff(now, days) {
     return new Date(now.getTime() - days * 86_400_000);
 }
-/** Per-org retention override row (Phase 7). Both nullable ⇒ global defaults. */
-//# sourceMappingURL=data:application/json;base64,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
+/** Per-org retention override row. Both nullable ⇒ global defaults. */
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/reporting/sql-helpers.d.ts

@@ -15,11 +15,6 @@ export declare function assertReportInterval(interval: string): void;
  * string field is funneled through this before insert.
  */
 export declare function scrubOptional(value: string | undefined): string | undefined;
-/**
- * Cache for reporting aggregations. Two tiers:
- * - Inventory queries (plugin summary/distribution/versions): 5 min TTL — changes on plugin CRUD
- * - Execution/build queries with date ranges: 2 min TTL — new events arrive continuously
- */
 /**
  * Roll a group of deploy/stage events (grouped per execution) up to one terminal
  * status: FAILED wins, then SUCCEEDED, else OTHER (still-running / non-terminal).
@@ -28,6 +23,8 @@ export declare function scrubOptional(value: string | undefined): string | undef
  * grouped event alias is `e`.
  */
 export declare const terminalStatusRollup: import("drizzle-orm").SQL<unknown>;
+/** The report window on `e.started_at` (inclusive `[from, to]`). */
+export declare function startedAtWindow(from: string, to: string): ReturnType<typeof sql>;
 /** Optional `[from,to]` window on `e.started_at` for the execution reports —
  *  a no-op `sql` fragment when either bound is absent (all-time). Shared by the
  *  execution-count and per-pipeline-execution reports so they narrow identically. */
@@ -36,10 +33,10 @@ export declare function optionalStartedAtRange(range?: {
     to?: string;
 }): ReturnType<typeof sql>;
 /**
- * Per-execution terminal deploy row (D1 — one row per (environment, execution),
+ * Per-execution terminal deploy row (one row per (environment, execution),
  * NOT per stage). The SQL rolls every deploy STAGE targeting an env within an
  * execution up to a single terminal status; the JS shaping buckets these by
- * environment. `commit_ts` (D2) is the execution's EARLIEST commit time across
+ * environment. `commit_ts` is the execution's EARLIEST commit time across
  * all its events — commit enrichment rides the PIPELINE/source event, not the
  * deploy STAGE — joined by execution_id (null when unresolved → lead `unknown`).
  * `in_window` is false for a look-back-only row kept solely so incidents opened

package/lib/api/reporting/sql-helpers.js

@@ -27,11 +27,6 @@ export function assertReportInterval(interval) {
 export function scrubOptional(value) {
     return value !== undefined ? scrubAwsIdentifiersFromString(value) : undefined;
 }
-/**
- * Cache for reporting aggregations. Two tiers:
- * - Inventory queries (plugin summary/distribution/versions): 5 min TTL — changes on plugin CRUD
- * - Execution/build queries with date ranges: 2 min TTL — new events arrive continuously
- */
 /**
  * Roll a group of deploy/stage events (grouped per execution) up to one terminal
  * status: FAILED wins, then SUCCEEDED, else OTHER (still-running / non-terminal).
@@ -44,22 +39,26 @@ export const terminalStatusRollup = sql `CASE
               WHEN bool_or(e.status = 'SUCCEEDED') THEN 'SUCCEEDED'
               ELSE 'OTHER'
             END`;
+/** The report window on `e.started_at` (inclusive `[from, to]`). */
+export function startedAtWindow(from, to) {
+    return sql `e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz`;
+}
 /** Optional `[from,to]` window on `e.started_at` for the execution reports —
  *  a no-op `sql` fragment when either bound is absent (all-time). Shared by the
  *  execution-count and per-pipeline-execution reports so they narrow identically. */
 export function optionalStartedAtRange(range) {
     return range?.from && range?.to
-        ? sql `AND e.started_at >= ${range.from}::timestamptz AND e.started_at <= ${range.to}::timestamptz`
+        ? sql `AND ${startedAtWindow(range.from, range.to)}`
         : sql ``;
 }
 /**
- * Per-execution terminal deploy row (D1 — one row per (environment, execution),
+ * Per-execution terminal deploy row (one row per (environment, execution),
  * NOT per stage). The SQL rolls every deploy STAGE targeting an env within an
  * execution up to a single terminal status; the JS shaping buckets these by
- * environment. `commit_ts` (D2) is the execution's EARLIEST commit time across
+ * environment. `commit_ts` is the execution's EARLIEST commit time across
  * all its events — commit enrichment rides the PIPELINE/source event, not the
  * deploy STAGE — joined by execution_id (null when unresolved → lead `unknown`).
  * `in_window` is false for a look-back-only row kept solely so incidents opened
  * near `from` can correlate to a deploy that completed just before the window.
  */
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/reporting/types.d.ts

@@ -103,6 +103,37 @@ export interface BuildDuration {
     maxMs: number;
     builds: number;
 }
+/**
+ * Plugin runtime report filters. `publisher: null` selects own-org
+ * (publisher-less) plugins; an omitted field doesn't filter.
+ */
+export interface PluginRuntimeFilter {
+    name?: string;
+    publisher?: string | null;
+    version?: string;
+}
+/** Per plugin version runtime stats over a window (terminal ACTION runs). */
+export interface PluginRuntimeStats {
+    pluginPublisher: string | null;
+    pluginName: string;
+    pluginVersion: string;
+    runs: number;
+    succeeded: number;
+    failed: number;
+    /** 0–100, one decimal. */
+    successPct: number;
+    /** Null when no run in the group carried a duration. */
+    p50Ms: number | null;
+    p95Ms: number | null;
+    lastRun: string;
+}
+/** Cross-org 30-day aggregate for one `(publisher, name)` listing. */
+export interface PluginRuntimeAggregate {
+    runs30d: number;
+    /** 0–1; null when there were no runs. */
+    successRate30d: number | null;
+    activeOrgCount30d: number;
+}
 export interface BuildFailure {
     pluginName: string;
     errorMessage: string;
@@ -114,7 +145,7 @@ export interface BuildFailure {
  * industry-standard DORA signal; MTTR is measured production-only, and this
  * environment's card is the summary shown at the top of the panel.
  */
-/** Per-org retention override row (Phase 7). Both nullable ⇒ global defaults. */
+/** Per-org retention override row. Both nullable ⇒ global defaults. */
 export interface ReportingRetentionSettings {
     eventRetentionDays: number | null;
     doraRetentionDays: number | null;
@@ -130,6 +161,15 @@ export interface ReportingRetentionOptions {
     maxBatchesPerTable?: number;
     /** Fixed "now" for the whole sweep (default `new Date()`). */
     now?: Date;
+    /**
+     * Resolve the org whose `dora_settings` retention governs `orgId`'s rows — its
+     * account ROOT. Retention is a billing entitlement synced onto the root only,
+     * so a team's rows must follow the root's (purchased) window, not the env
+     * default. Return `null` when the root can't be resolved: that org is SKIPPED
+     * this tick (never purged on a possibly-shorter window). Default: identity
+     * (every org is its own root — a flat deployment).
+     */
+    resolveRetentionOrgId?: (orgId: string) => Promise<string | null>;
 }
 /** Per-run purge tallies (also logged). */
 export interface ReportingRetentionCounts {
@@ -160,32 +200,32 @@ export interface DoraOptions {
      * Per-org incident→deploy correlation window override (hours). When set (a
      * positive finite number), the incident correlation uses it instead of the
      * global `DORA_INCIDENT_WINDOW_HOURS`. The route resolves this from the org's
-     * `dora_settings` row (see {@link ReportingService.getIncidentSettings}) and
+     * `dora_settings` row (see {@link ReportingService.getReportingSettings}) and
      * passes it in; unset falls back to the env default.
      */
     incidentWindowHours?: number;
 }
 /**
  * Per-org reporting settings surfaced to the org-admin panel. `incidentWindowHours`
- * (Phase 5b) is the incident→deploy correlation window; `eventRetentionDays` /
- * `doraRetentionDays` (Phase 7) are the two retention-sweep windows. Each override
+ * is the incident→deploy correlation window; `eventRetentionDays` /
+ * `doraRetentionDays` are the two retention-sweep windows. Each override
  * is `null` when unset (the paired `default*` field shows the env fallback applied).
  */
-export interface IncidentSettings {
+export interface ReportingSettings {
     /** The org's stored correlation-window override in hours, or `null` when unset. */
     incidentWindowHours: number | null;
     /** The global env default applied when no override is stored. */
     defaultWindowHours: number;
-    /** Standard-event retention override in days, or `null` when unset (Phase 7). */
+    /** Standard-event retention override in days, or `null` when unset. */
     eventRetentionDays: number | null;
-    /** DORA-source retention override in days, or `null` when unset (Phase 7). */
+    /** DORA-source retention override in days, or `null` when unset. */
     doraRetentionDays: number | null;
     /** Global standard-event retention default applied when unset (days). */
     defaultEventRetentionDays: number;
     /** Global DORA-source retention default applied when unset (days). */
     defaultDoraRetentionDays: number;
 }
-/** A partial reporting-settings write (Phase 5b + 7). Only provided fields are
+/** A partial reporting-settings write (7). Only provided fields are
  *  upserted; omitted fields are left unchanged (an omitted retention field keeps
  *  its stored override / the global default). */
 export interface ReportingSettingsPatch {
@@ -327,7 +367,7 @@ export interface DoraTrendPoint {
     /** failed/total as a percent (0 when total is 0). Deploy-time CFR only. */
     changeFailurePct: number;
 }
-/** Per-stage build-health metrics (Phase 6) for one pipeline over a window. */
+/** Per-stage build-health metrics for one pipeline over a window. */
 export interface BuildHealthStage {
     stage: string;
     /** Terminal stage runs (succeeded + failed) in the window. */
@@ -342,7 +382,7 @@ export interface BuildHealthStage {
     p99Ms: number | null;
 }
 /**
- * Per-pipeline build-health breakdown (Phase 6). Standard reporting (NOT
+ * Per-pipeline build-health breakdown. Standard reporting (NOT
  * `advanced_reporting`-gated) — per-stage success rate + timing percentiles, with
  * totals summed across stages.
  */
@@ -354,7 +394,7 @@ export interface BuildHealth {
         failureRate: number;
     };
 }
-/** Post-deploy incident marker (Phase 5) accepted by `ReportingService.recordIncident`. */
+/** Post-deploy incident marker accepted by `ReportingService.recordIncident`. */
 export interface IncidentInput {
     incidentId: string;
     environment: string;
@@ -414,16 +454,14 @@ export interface IngestResult {
      * Every org with at least one row in this batch, deduped.
      *
      * Already computed for post-commit cache invalidation; surfaced because the
-     * ingest route needs the same set to push its live SSE frame. That fan-out
-     * used to be driven off the stage-metric hook, which only fires for STAGE
-     * events — so a batch of PIPELINE or BUILD events landed rows and pushed no
-     * frame at all, and the dashboard silently went back to needing a manual
-     * refresh for exactly the events an execution view is about.
+     * ingest route needs the same set to push its live SSE frame. The stage-metric
+     * hook can't drive that fan-out: it only fires for STAGE events, so a batch of
+     * PIPELINE or BUILD events would land rows and push no frame at all.
      */
     affectedOrgs: string[];
 }
 /**
- * One org's ingestion-health row as READ back by the Reports UI (Phase 3). The
+ * One org's ingestion-health row as READ back by the Reports UI. The
  * AWS events Lambda writes it; this is the shape that lets the UI tell
  * "ingestion is healthy, there were simply no deploys in the range" apart from
  * "we haven't heard from the ingest pipeline since X".