@pipeline-builder/pipeline-data 3.1.0

package/lib/api/reporting-service.js

@@ -0,0 +1,248 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportingService = exports.ReportingService = void 0;
+const api_core_1 = require("@pipeline-builder/api-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const crud_service_1 = require("./crud-service");
+const drizzle_schema_1 = require("../database/drizzle-schema");
+const postgres_connection_1 = require("../database/postgres-connection");
+/** Cast raw SQL result rows to a typed array. Alias for drizzleRows. */
+const sqlRows = (result) => (0, crud_service_1.drizzleRows)(result.rows);
+/**
+ * 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
+ */
+const inventoryCache = (0, api_core_1.createCacheService)('report:inv:', parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10));
+const timeseriesCache = (0, api_core_1.createCacheService)('report:ts:', parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10));
+// ─── Service ────────────────────────────────────────────
+/**
+ * Read-only reporting service for pipeline execution and plugin inventory aggregations.
+ * Does not extend CrudService — reports are aggregate queries, not entity CRUD.
+ *
+ * All queries are cached in-memory to avoid repeated expensive SQL aggregations:
+ * - Inventory queries (plugin summary/distribution/versions): 5 min TTL
+ * - Timeseries queries (execution/build metrics with date ranges): 2 min TTL
+ */
+class ReportingService {
+    /** Invalidate all cached reports for an org (call after event ingest). */
+    async invalidateOrg(orgId) {
+        await Promise.all([
+            inventoryCache.invalidatePattern(`${orgId}:*`),
+            timeseriesCache.invalidatePattern(`${orgId}:*`),
+        ]);
+    }
+    // ── Category 1: Pipeline Execution & Performance ──
+    /** 1.1 Execution count per pipeline with status breakdown. */
+    async getExecutionCount(orgId) {
+        return timeseriesCache.getOrSet(`${orgId}:exec-count`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          p.id, p.project, p.organization, p.pipeline_name,
+          COUNT(*)::int AS total,
+          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,
+          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,
+          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,
+          MIN(e.started_at)::text AS first_execution,
+          MAX(e.started_at)::text AS last_execution
+        FROM ${drizzle_schema_1.schema.pipeline} p
+        JOIN ${drizzle_schema_1.schema.pipelineEvent} e ON e.pipeline_id = p.id
+          AND e.event_type = 'PIPELINE' AND e.status != 'STARTED'
+        WHERE p.org_id = ${orgId} AND p.is_active = true
+        GROUP BY p.id
+        ORDER BY total DESC
+      `).then(r => sqlRows(r)));
+    }
+    /** 1.2 Success rate over time for an org. */
+    async getSuccessRate(orgId, interval, from, to) {
+        return timeseriesCache.getOrSet(`${orgId}:success-rate:${interval}:${from}:${to}`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          DATE_TRUNC(${interval}, e.started_at)::text AS period,
+          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,
+          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,
+          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,
+          ROUND(COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::numeric
+            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct
+        FROM ${drizzle_schema_1.schema.pipelineEvent} e
+        JOIN ${drizzle_schema_1.schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id = ${orgId} AND e.event_type = 'PIPELINE'
+          AND e.status IN ('SUCCEEDED', 'FAILED', 'CANCELED')
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY period ORDER BY period
+      `).then(r => sqlRows(r)));
+    }
+    /** 1.3 Average duration per pipeline. */
+    async getAverageDuration(orgId, from, to) {
+        return timeseriesCache.getOrSet(`${orgId}:avg-duration:${from}:${to}`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          p.id, p.project, p.pipeline_name,
+          AVG(e.duration_ms)::int AS avg_ms,
+          MIN(e.duration_ms)::int AS min_ms,
+          MAX(e.duration_ms)::int AS max_ms,
+          PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY e.duration_ms)::int AS p95_ms,
+          COUNT(*)::int AS executions
+        FROM ${drizzle_schema_1.schema.pipelineEvent} e
+        JOIN ${drizzle_schema_1.schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id = ${orgId} AND e.event_type = 'PIPELINE' AND e.duration_ms IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY p.id ORDER BY avg_ms DESC
+      `).then(r => sqlRows(r)));
+    }
+    /** 1.5 Stage failure heatmap — which stages fail most. */
+    async getStageFailures(orgId, from, to) {
+        return timeseriesCache.getOrSet(`${orgId}:stage-failures:${from}:${to}`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          e.stage_name,
+          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,
+          COUNT(*)::int AS total,
+          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric
+            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct
+        FROM ${drizzle_schema_1.schema.pipelineEvent} e
+        JOIN ${drizzle_schema_1.schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id = ${orgId} AND e.event_type = 'STAGE' AND e.stage_name IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY e.stage_name ORDER BY failures DESC
+      `).then(r => sqlRows(r)));
+    }
+    /** 1.6 Stage bottlenecks — slowest stages per pipeline. */
+    async getStageBottlenecks(orgId, from, to) {
+        return timeseriesCache.getOrSet(`${orgId}:stage-bottlenecks:${from}:${to}`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          p.id, p.pipeline_name, e.stage_name,
+          AVG(e.duration_ms)::int AS avg_ms,
+          MAX(e.duration_ms)::int AS max_ms
+        FROM ${drizzle_schema_1.schema.pipelineEvent} e
+        JOIN ${drizzle_schema_1.schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id = ${orgId} AND e.event_type = 'STAGE' AND e.duration_ms IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY p.id, e.stage_name ORDER BY avg_ms DESC
+      `).then(r => sqlRows(r)));
+    }
+    /** 1.7 Action failure rate — which plugin steps fail most. */
+    async getActionFailures(orgId, from, to) {
+        return timeseriesCache.getOrSet(`${orgId}:action-failures:${from}:${to}`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          e.action_name,
+          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,
+          COUNT(*)::int AS total,
+          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric
+            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct
+        FROM ${drizzle_schema_1.schema.pipelineEvent} e
+        JOIN ${drizzle_schema_1.schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id = ${orgId} AND e.event_type = 'ACTION' AND e.action_name IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY e.action_name ORDER BY failures DESC
+      `).then(r => sqlRows(r)));
+    }
+    /** 1.8 Error categorization — group failure messages. */
+    async getErrors(orgId, from, to, limit = 20) {
+        return timeseriesCache.getOrSet(`${orgId}:errors:${from}:${to}:${limit}`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          SUBSTRING(e.error_message FROM 1 FOR 200) AS error_pattern,
+          COUNT(*)::int AS occurrences,
+          COUNT(DISTINCT e.pipeline_id)::int AS affected_pipelines,
+          MAX(e.started_at)::text AS last_seen
+        FROM ${drizzle_schema_1.schema.pipelineEvent} e
+        JOIN ${drizzle_schema_1.schema.pipeline} p ON p.id = e.pipeline_id
+        WHERE p.org_id = ${orgId} AND e.status = 'FAILED' AND e.error_message IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY error_pattern ORDER BY occurrences DESC
+        LIMIT ${limit}
+      `).then(r => sqlRows(r)));
+    }
+    // ── Category 2: Plugin Inventory & Builds ──
+    /** 2.1 Plugin summary — counts and breakdowns. */
+    async getPluginSummary(orgId) {
+        return inventoryCache.getOrSet(`${orgId}:plugin-summary`, async () => {
+            const rows = await postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          COUNT(*)::int AS total,
+          COUNT(*) FILTER (WHERE ${drizzle_schema_1.schema.plugin.isActive})::int AS active,
+          COUNT(*) FILTER (WHERE NOT ${drizzle_schema_1.schema.plugin.isActive})::int AS inactive,
+          COUNT(*) FILTER (WHERE ${drizzle_schema_1.schema.plugin.accessModifier} = 'public')::int AS public,
+          COUNT(*) FILTER (WHERE ${drizzle_schema_1.schema.plugin.accessModifier} = 'private')::int AS private,
+          COUNT(DISTINCT ${drizzle_schema_1.schema.plugin.name})::int AS unique_names
+        FROM ${drizzle_schema_1.schema.plugin}
+        WHERE ${drizzle_schema_1.schema.plugin.orgId} = ${orgId}
+      `);
+            return (sqlRows(rows)[0] || { total: 0, active: 0, inactive: 0, public: 0, private: 0, uniqueNames: 0 });
+        });
+    }
+    /** 2.2 Type & compute distribution. */
+    async getPluginDistribution(orgId) {
+        return inventoryCache.getOrSet(`${orgId}:plugin-distribution`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          ${drizzle_schema_1.schema.plugin.pluginType} AS plugin_type,
+          ${drizzle_schema_1.schema.plugin.computeType} AS compute_type,
+          COUNT(*)::int AS count
+        FROM ${drizzle_schema_1.schema.plugin}
+        WHERE ${drizzle_schema_1.schema.plugin.orgId} = ${orgId} AND ${drizzle_schema_1.schema.plugin.isActive} = true
+        GROUP BY ${drizzle_schema_1.schema.plugin.pluginType}, ${drizzle_schema_1.schema.plugin.computeType}
+        ORDER BY count DESC
+      `).then(r => sqlRows(r)));
+    }
+    /** 2.3 Version counts per plugin name. */
+    async getPluginVersions(orgId) {
+        return inventoryCache.getOrSet(`${orgId}:plugin-versions`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          ${drizzle_schema_1.schema.plugin.name},
+          COUNT(*)::int AS version_count,
+          MAX(${drizzle_schema_1.schema.plugin.version}) AS latest_version,
+          bool_or(${drizzle_schema_1.schema.plugin.isDefault}) AS has_default
+        FROM ${drizzle_schema_1.schema.plugin}
+        WHERE ${drizzle_schema_1.schema.plugin.orgId} = ${orgId} AND ${drizzle_schema_1.schema.plugin.isActive} = true
+        GROUP BY ${drizzle_schema_1.schema.plugin.name}
+        ORDER BY version_count DESC
+      `).then(r => sqlRows(r)));
+    }
+    /** 2.4 Build success rate over time. */
+    async getBuildSuccessRate(orgId, interval, from, to) {
+        return timeseriesCache.getOrSet(`${orgId}:build-success:${interval}:${from}:${to}`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          DATE_TRUNC(${interval}, e.started_at)::text AS period,
+          COUNT(*) FILTER (WHERE e.status = 'completed')::int AS succeeded,
+          COUNT(*) FILTER (WHERE e.status = 'failed')::int AS failed,
+          ROUND(COUNT(*) FILTER (WHERE e.status = 'completed')::numeric
+            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct
+        FROM ${drizzle_schema_1.schema.pipelineEvent} e
+        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build'
+          AND e.status IN ('completed', 'failed')
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY period ORDER BY period
+      `).then(r => sqlRows(r)));
+    }
+    /** 2.5 Build duration per plugin. */
+    async getBuildDuration(orgId, from, to) {
+        return timeseriesCache.getOrSet(`${orgId}:build-duration:${from}:${to}`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          e.detail->>'pluginName' AS plugin_name,
+          AVG(e.duration_ms)::int AS avg_ms,
+          MAX(e.duration_ms)::int AS max_ms,
+          COUNT(*)::int AS builds
+        FROM ${drizzle_schema_1.schema.pipelineEvent} e
+        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build' AND e.duration_ms IS NOT NULL
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY plugin_name ORDER BY avg_ms DESC
+      `).then(r => sqlRows(r)));
+    }
+    /** 2.6 Build failures — top error messages. */
+    async getBuildFailures(orgId, from, to, limit = 20) {
+        return timeseriesCache.getOrSet(`${orgId}:build-failures:${from}:${to}:${limit}`, () => postgres_connection_1.db.execute((0, drizzle_orm_1.sql) `
+        SELECT
+          e.detail->>'pluginName' AS plugin_name,
+          e.error_message,
+          COUNT(*)::int AS occurrences,
+          MAX(e.started_at)::text AS last_seen
+        FROM ${drizzle_schema_1.schema.pipelineEvent} e
+        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build' AND e.status = 'failed'
+          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz
+        GROUP BY plugin_name, e.error_message
+        ORDER BY occurrences DESC
+        LIMIT ${limit}
+      `).then(r => sqlRows(r)));
+    }
+}
+exports.ReportingService = ReportingService;
+exports.reportingService = new ReportingService();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reporting-service.js","sourceRoot":"","sources":["../../src/api/reporting-service.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createCacheService } from '@pipeline-builder/api-core';\nimport { sql } from 'drizzle-orm';\nimport { drizzleRows } from './crud-service';\nimport { schema } from '../database/drizzle-schema';\nimport { db } from '../database/postgres-connection';\n\n/** Cast raw SQL result rows to a typed array. Alias for drizzleRows. */\nconst sqlRows = <T>(result: { rows: unknown[] }): T[] => drizzleRows<T>(result.rows);\n\n/**\n * Cache for reporting aggregations. Two tiers:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL — changes on plugin CRUD\n * - Execution/build queries with date ranges: 2 min TTL — new events arrive continuously\n */\nconst inventoryCache = createCacheService('report:inv:', parseInt(process.env.CACHE_TTL_REPORT_INVENTORY || '300', 10));\nconst timeseriesCache = createCacheService('report:ts:', parseInt(process.env.CACHE_TTL_REPORT_TIMESERIES || '120', 10));\n\n// ─── Types ──────────────────────────────────────────────\n\ninterface ExecutionCount {\n  id: string;\n  project: string;\n  organization: string;\n  pipelineName: string | null;\n  total: number;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  firstExecution: string | null;\n  lastExecution: string | null;\n}\n\ninterface TimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  canceled: number;\n  successPct: number;\n}\n\ninterface DurationStats {\n  id: string;\n  project: string;\n  pipelineName: string | null;\n  avgMs: number;\n  minMs: number;\n  maxMs: number;\n  p95Ms: number;\n  executions: number;\n}\n\ninterface StageFailure {\n  stageName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\ninterface StageBottleneck {\n  id: string;\n  pipelineName: string | null;\n  stageName: string;\n  avgMs: number;\n  maxMs: number;\n}\n\ninterface ActionFailure {\n  actionName: string;\n  failures: number;\n  total: number;\n  failurePct: number;\n}\n\ninterface ErrorEntry {\n  errorPattern: string;\n  occurrences: number;\n  affectedPipelines: number;\n  lastSeen: string;\n}\n\ninterface PluginSummary {\n  total: number;\n  active: number;\n  inactive: number;\n  public: number;\n  private: number;\n  uniqueNames: number;\n}\n\ninterface TypeComputeDistribution {\n  pluginType: string;\n  computeType: string;\n  count: number;\n}\n\ninterface VersionCount {\n  name: string;\n  versionCount: number;\n  latestVersion: string;\n  hasDefault: boolean;\n}\n\ninterface BuildTimeSeriesEntry {\n  period: string;\n  succeeded: number;\n  failed: number;\n  successPct: number;\n}\n\ninterface BuildDuration {\n  pluginName: string;\n  avgMs: number;\n  maxMs: number;\n  builds: number;\n}\n\ninterface BuildFailure {\n  pluginName: string;\n  errorMessage: string;\n  occurrences: number;\n  lastSeen: string;\n}\n\n// ─── Service ────────────────────────────────────────────\n\n/**\n * Read-only reporting service for pipeline execution and plugin inventory aggregations.\n * Does not extend CrudService — reports are aggregate queries, not entity CRUD.\n *\n * All queries are cached in-memory to avoid repeated expensive SQL aggregations:\n * - Inventory queries (plugin summary/distribution/versions): 5 min TTL\n * - Timeseries queries (execution/build metrics with date ranges): 2 min TTL\n */\nexport class ReportingService {\n\n  /** Invalidate all cached reports for an org (call after event ingest). */\n  async invalidateOrg(orgId: string): Promise<void> {\n    await Promise.all([\n      inventoryCache.invalidatePattern(`${orgId}:*`),\n      timeseriesCache.invalidatePattern(`${orgId}:*`),\n    ]);\n  }\n\n  // ── Category 1: Pipeline Execution & Performance ──\n\n  /** 1.1 Execution count per pipeline with status breakdown. */\n  async getExecutionCount(orgId: string): Promise<ExecutionCount[]> {\n    return timeseriesCache.getOrSet(`${orgId}:exec-count`, () =>\n      db.execute(sql`\n        SELECT\n          p.id, p.project, p.organization, p.pipeline_name,\n          COUNT(*)::int AS total,\n          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,\n          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,\n          MIN(e.started_at)::text AS first_execution,\n          MAX(e.started_at)::text AS last_execution\n        FROM ${schema.pipeline} p\n        JOIN ${schema.pipelineEvent} e ON e.pipeline_id = p.id\n          AND e.event_type = 'PIPELINE' AND e.status != 'STARTED'\n        WHERE p.org_id = ${orgId} AND p.is_active = true\n        GROUP BY p.id\n        ORDER BY total DESC\n      `).then(r => sqlRows<ExecutionCount>(r)),\n    );\n  }\n\n  /** 1.2 Success rate over time for an org. */\n  async getSuccessRate(orgId: string, interval: string, from: string, to: string): Promise<TimeSeriesEntry[]> {\n    return timeseriesCache.getOrSet(`${orgId}:success-rate:${interval}:${from}:${to}`, () =>\n      db.execute(sql`\n        SELECT\n          DATE_TRUNC(${interval}, e.started_at)::text AS period,\n          COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failed,\n          COUNT(*) FILTER (WHERE e.status = 'CANCELED')::int AS canceled,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'SUCCEEDED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id = ${orgId} AND e.event_type = 'PIPELINE'\n          AND e.status IN ('SUCCEEDED', 'FAILED', 'CANCELED')\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY period ORDER BY period\n      `).then(r => sqlRows<TimeSeriesEntry>(r)),\n    );\n  }\n\n  /** 1.3 Average duration per pipeline. */\n  async getAverageDuration(orgId: string, from: string, to: string): Promise<DurationStats[]> {\n    return timeseriesCache.getOrSet(`${orgId}:avg-duration:${from}:${to}`, () =>\n      db.execute(sql`\n        SELECT\n          p.id, p.project, p.pipeline_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MIN(e.duration_ms)::int AS min_ms,\n          MAX(e.duration_ms)::int AS max_ms,\n          PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY e.duration_ms)::int AS p95_ms,\n          COUNT(*)::int AS executions\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id = ${orgId} AND e.event_type = 'PIPELINE' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY p.id ORDER BY avg_ms DESC\n      `).then(r => sqlRows<DurationStats>(r)),\n    );\n  }\n\n  /** 1.5 Stage failure heatmap — which stages fail most. */\n  async getStageFailures(orgId: string, from: string, to: string): Promise<StageFailure[]> {\n    return timeseriesCache.getOrSet(`${orgId}:stage-failures:${from}:${to}`, () =>\n      db.execute(sql`\n        SELECT\n          e.stage_name,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,\n          COUNT(*)::int AS total,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id = ${orgId} AND e.event_type = 'STAGE' AND e.stage_name IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY e.stage_name ORDER BY failures DESC\n      `).then(r => sqlRows<StageFailure>(r)),\n    );\n  }\n\n  /** 1.6 Stage bottlenecks — slowest stages per pipeline. */\n  async getStageBottlenecks(orgId: string, from: string, to: string): Promise<StageBottleneck[]> {\n    return timeseriesCache.getOrSet(`${orgId}:stage-bottlenecks:${from}:${to}`, () =>\n      db.execute(sql`\n        SELECT\n          p.id, p.pipeline_name, e.stage_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MAX(e.duration_ms)::int AS max_ms\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id = ${orgId} AND e.event_type = 'STAGE' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY p.id, e.stage_name ORDER BY avg_ms DESC\n      `).then(r => sqlRows<StageBottleneck>(r)),\n    );\n  }\n\n  /** 1.7 Action failure rate — which plugin steps fail most. */\n  async getActionFailures(orgId: string, from: string, to: string): Promise<ActionFailure[]> {\n    return timeseriesCache.getOrSet(`${orgId}:action-failures:${from}:${to}`, () =>\n      db.execute(sql`\n        SELECT\n          e.action_name,\n          COUNT(*) FILTER (WHERE e.status = 'FAILED')::int AS failures,\n          COUNT(*)::int AS total,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'FAILED')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS failure_pct\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id = ${orgId} AND e.event_type = 'ACTION' AND e.action_name IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY e.action_name ORDER BY failures DESC\n      `).then(r => sqlRows<ActionFailure>(r)),\n    );\n  }\n\n  /** 1.8 Error categorization — group failure messages. */\n  async getErrors(orgId: string, from: string, to: string, limit: number = 20): Promise<ErrorEntry[]> {\n    return timeseriesCache.getOrSet(`${orgId}:errors:${from}:${to}:${limit}`, () =>\n      db.execute(sql`\n        SELECT\n          SUBSTRING(e.error_message FROM 1 FOR 200) AS error_pattern,\n          COUNT(*)::int AS occurrences,\n          COUNT(DISTINCT e.pipeline_id)::int AS affected_pipelines,\n          MAX(e.started_at)::text AS last_seen\n        FROM ${schema.pipelineEvent} e\n        JOIN ${schema.pipeline} p ON p.id = e.pipeline_id\n        WHERE p.org_id = ${orgId} AND e.status = 'FAILED' AND e.error_message IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY error_pattern ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `).then(r => sqlRows<ErrorEntry>(r)),\n    );\n  }\n\n  // ── Category 2: Plugin Inventory & Builds ──\n\n  /** 2.1 Plugin summary — counts and breakdowns. */\n  async getPluginSummary(orgId: string): Promise<PluginSummary> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-summary`, async () => {\n      const rows = await db.execute(sql`\n        SELECT\n          COUNT(*)::int AS total,\n          COUNT(*) FILTER (WHERE ${schema.plugin.isActive})::int AS active,\n          COUNT(*) FILTER (WHERE NOT ${schema.plugin.isActive})::int AS inactive,\n          COUNT(*) FILTER (WHERE ${schema.plugin.accessModifier} = 'public')::int AS public,\n          COUNT(*) FILTER (WHERE ${schema.plugin.accessModifier} = 'private')::int AS private,\n          COUNT(DISTINCT ${schema.plugin.name})::int AS unique_names\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId}\n      `);\n      return (sqlRows<PluginSummary>(rows)[0] || { total: 0, active: 0, inactive: 0, public: 0, private: 0, uniqueNames: 0 });\n    });\n  }\n\n  /** 2.2 Type & compute distribution. */\n  async getPluginDistribution(orgId: string): Promise<TypeComputeDistribution[]> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-distribution`, () =>\n      db.execute(sql`\n        SELECT\n          ${schema.plugin.pluginType} AS plugin_type,\n          ${schema.plugin.computeType} AS compute_type,\n          COUNT(*)::int AS count\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true\n        GROUP BY ${schema.plugin.pluginType}, ${schema.plugin.computeType}\n        ORDER BY count DESC\n      `).then(r => sqlRows<TypeComputeDistribution>(r)),\n    );\n  }\n\n  /** 2.3 Version counts per plugin name. */\n  async getPluginVersions(orgId: string): Promise<VersionCount[]> {\n    return inventoryCache.getOrSet(`${orgId}:plugin-versions`, () =>\n      db.execute(sql`\n        SELECT\n          ${schema.plugin.name},\n          COUNT(*)::int AS version_count,\n          MAX(${schema.plugin.version}) AS latest_version,\n          bool_or(${schema.plugin.isDefault}) AS has_default\n        FROM ${schema.plugin}\n        WHERE ${schema.plugin.orgId} = ${orgId} AND ${schema.plugin.isActive} = true\n        GROUP BY ${schema.plugin.name}\n        ORDER BY version_count DESC\n      `).then(r => sqlRows<VersionCount>(r)),\n    );\n  }\n\n  /** 2.4 Build success rate over time. */\n  async getBuildSuccessRate(orgId: string, interval: string, from: string, to: string): Promise<BuildTimeSeriesEntry[]> {\n    return timeseriesCache.getOrSet(`${orgId}:build-success:${interval}:${from}:${to}`, () =>\n      db.execute(sql`\n        SELECT\n          DATE_TRUNC(${interval}, e.started_at)::text AS period,\n          COUNT(*) FILTER (WHERE e.status = 'completed')::int AS succeeded,\n          COUNT(*) FILTER (WHERE e.status = 'failed')::int AS failed,\n          ROUND(COUNT(*) FILTER (WHERE e.status = 'completed')::numeric\n            / NULLIF(COUNT(*), 0) * 100, 1)::float AS success_pct\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build'\n          AND e.status IN ('completed', 'failed')\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY period ORDER BY period\n      `).then(r => sqlRows<BuildTimeSeriesEntry>(r)),\n    );\n  }\n\n  /** 2.5 Build duration per plugin. */\n  async getBuildDuration(orgId: string, from: string, to: string): Promise<BuildDuration[]> {\n    return timeseriesCache.getOrSet(`${orgId}:build-duration:${from}:${to}`, () =>\n      db.execute(sql`\n        SELECT\n          e.detail->>'pluginName' AS plugin_name,\n          AVG(e.duration_ms)::int AS avg_ms,\n          MAX(e.duration_ms)::int AS max_ms,\n          COUNT(*)::int AS builds\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build' AND e.duration_ms IS NOT NULL\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY plugin_name ORDER BY avg_ms DESC\n      `).then(r => sqlRows<BuildDuration>(r)),\n    );\n  }\n\n  /** 2.6 Build failures — top error messages. */\n  async getBuildFailures(orgId: string, from: string, to: string, limit: number = 20): Promise<BuildFailure[]> {\n    return timeseriesCache.getOrSet(`${orgId}:build-failures:${from}:${to}:${limit}`, () =>\n      db.execute(sql`\n        SELECT\n          e.detail->>'pluginName' AS plugin_name,\n          e.error_message,\n          COUNT(*)::int AS occurrences,\n          MAX(e.started_at)::text AS last_seen\n        FROM ${schema.pipelineEvent} e\n        WHERE e.org_id = ${orgId} AND e.event_source = 'plugin-build' AND e.status = 'failed'\n          AND e.started_at >= ${from}::timestamptz AND e.started_at <= ${to}::timestamptz\n        GROUP BY plugin_name, e.error_message\n        ORDER BY occurrences DESC\n        LIMIT ${limit}\n      `).then(r => sqlRows<BuildFailure>(r)),\n    );\n  }\n}\n\nexport const reportingService = new ReportingService();\n"]}

package/lib/core/query-filters.d.ts

@@ -0,0 +1,235 @@
+import { AccessModifier } from '@pipeline-builder/api-core';
+/**
+ * Base filter interface containing common filter properties shared across all entity types.
+ *
+ * @example
+ * ```typescript
+ * const filter: CommonFilter = {
+ *   id: '123',
+ *   orgId: 'my-org',
+ *   accessModifier: AccessModifier.PUBLIC,
+ *   isDefault: true,
+ *   isActive: true
+ * };
+ * ```
+ */
+export interface CommonFilter {
+    /**
+     * Unique identifier for the entity
+     * Can be a single ID or array of IDs for batch filtering
+     */
+    readonly id?: string | string[];
+    /**
+     * Organization identifier to filter entities by organization
+     * Can be a single org ID or array for multi-org filtering
+     */
+    readonly orgId?: string | string[];
+    /**
+     * Access modifier to filter by visibility/permissions
+     * Use AccessModifier enum for type safety
+     * @see AccessModifier
+     */
+    readonly accessModifier?: AccessModifier | string;
+    /**
+     * Filter by default status
+     * - true: Only default entities
+     * - false: Only non-default entities
+     * - undefined: All entities
+     */
+    readonly isDefault?: boolean;
+    /**
+     * Filter by active/inactive status
+     * - true: Only active entities
+     * - false: Only inactive entities
+     * - undefined: All entities
+     */
+    readonly isActive?: boolean;
+    /**
+     * Number of results to return
+     * @minimum 1
+     * @maximum 1000
+     */
+    readonly limit?: number;
+    /**
+     * Number of results to skip (for pagination)
+     * @minimum 0
+     */
+    readonly offset?: number;
+    /**
+     * Sort field and direction
+     * @example "name:asc", "createdAt:desc"
+     */
+    readonly sort?: string;
+}
+/**
+ * Filter interface for plugin-specific properties.
+ * Extends CommonFilter to include plugin-related filter options.
+ *
+ * @example
+ * ```typescript
+ * const filter: PluginFilter = {
+ *   name: 'nodejs-build',
+ *   version: '1.0.0',
+ *   isActive: true
+ * };
+ * ```
+ */
+export interface PluginFilter extends CommonFilter {
+    /**
+     * Plugin name to filter by
+     */
+    readonly name?: string;
+    /**
+     * Plugin version to filter by
+     * Supports semantic versioning
+     * @example "1.0.0", "^2.0.0", "~1.2.3"
+     */
+    readonly version?: string;
+    /**
+     * Docker image tag associated with the plugin
+     */
+    readonly imageTag?: string;
+    /**
+     * Keyword to search within the keywords JSONB array (case-insensitive contains)
+     */
+    readonly keyword?: string;
+    /**
+     * Plugin category to filter by
+     * @example "language", "security", "testing"
+     */
+    readonly category?: string;
+}
+/**
+ * Filter interface for pipeline-specific properties.
+ * Extends CommonFilter to include pipeline-related filter options.
+ *
+ * @example
+ * ```typescript
+ * const filter: PipelineFilter = {
+ *   project: 'my-app',
+ *   organization: 'my-org',
+ *   pipelineName: 'my-pipeline',
+ *   isActive: true
+ * };
+ * ```
+ */
+export interface PipelineFilter extends CommonFilter {
+    /**
+     * Project name associated with the pipeline
+     */
+    readonly project?: string;
+    /**
+     * Organization name associated with the pipeline
+     */
+    readonly organization?: string;
+    /**
+     * Pipeline name to filter by
+     */
+    readonly pipelineName?: string;
+    /**
+     * Keyword to search within the keywords JSONB array (case-insensitive contains)
+     */
+    readonly keyword?: string;
+}
+/**
+ * Filter interface for message-specific properties.
+ * Extends CommonFilter to include message-related filter options.
+ */
+export interface MessageFilter extends CommonFilter {
+    /**
+     * Thread ID to filter by (for fetching thread replies).
+     * Pass `null` to filter for root messages only (threadId IS NULL).
+     */
+    readonly threadId?: string | null;
+    /**
+     * Recipient organization ID to filter by
+     * Use '*' for broadcast announcements
+     */
+    readonly recipientOrgId?: string;
+    /**
+     * Message type filter
+     */
+    readonly messageType?: 'announcement' | 'conversation';
+    /**
+     * Filter by read status
+     */
+    readonly isRead?: boolean;
+    /**
+     * Filter by priority level
+     */
+    readonly priority?: 'normal' | 'high' | 'urgent';
+}
+/**
+ * Filter for compliance policies.
+ */
+export interface CompliancePolicyFilter extends CommonFilter {
+    readonly name?: string;
+    readonly isTemplate?: boolean;
+}
+/**
+ * Filter for compliance rules.
+ */
+export interface ComplianceRuleFilter extends CommonFilter {
+    readonly name?: string;
+    readonly policyId?: string;
+    readonly target?: 'plugin' | 'pipeline';
+    readonly field?: string;
+    readonly severity?: 'warning' | 'error' | 'critical';
+    readonly scope?: 'org' | 'published';
+    readonly tag?: string;
+}
+/**
+ * Filter for compliance rule subscriptions.
+ */
+export interface ComplianceRuleSubscriptionFilter {
+    readonly orgId?: string;
+    readonly ruleId?: string;
+    readonly isActive?: boolean;
+    readonly limit?: number;
+    readonly offset?: number;
+}
+/**
+ * Filter for compliance exemptions.
+ */
+export interface ComplianceExemptionFilter {
+    readonly orgId?: string;
+    readonly ruleId?: string;
+    readonly entityType?: 'plugin' | 'pipeline';
+    readonly entityId?: string;
+    readonly status?: 'pending' | 'approved' | 'rejected' | 'expired';
+    readonly limit?: number;
+    readonly offset?: number;
+}
+/**
+ * Filter for compliance audit log entries.
+ */
+export interface ComplianceAuditFilter {
+    readonly orgId?: string;
+    readonly target?: 'plugin' | 'pipeline';
+    readonly action?: string;
+    readonly result?: 'pass' | 'warn' | 'block';
+    readonly scanId?: string;
+    readonly dateFrom?: string;
+    readonly dateTo?: string;
+    readonly limit?: number;
+    readonly offset?: number;
+}
+/**
+ * Filter for compliance scans.
+ */
+export interface ComplianceScanFilter {
+    readonly orgId?: string;
+    readonly target?: 'plugin' | 'pipeline' | 'all';
+    readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    readonly triggeredBy?: 'manual' | 'scheduled' | 'rule-change' | 'rule-dry-run';
+    readonly limit?: number;
+    readonly offset?: number;
+}
+/**
+ * Validates message filter properties.
+ * Returns a result object with `valid` flag and `errors` array.
+ */
+export declare function validateMessageFilter(filter: Partial<MessageFilter>): {
+    valid: boolean;
+    errors: string[];
+};

package/lib/core/query-filters.js

@@ -0,0 +1,23 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMessageFilter = validateMessageFilter;
+/**
+ * Validates message filter properties.
+ * Returns a result object with `valid` flag and `errors` array.
+ */
+function validateMessageFilter(filter) {
+    const errors = [];
+    if (filter.messageType && !['announcement', 'conversation'].includes(filter.messageType)) {
+        errors.push(`Invalid messageType: "${filter.messageType}". Must be "announcement" or "conversation"`);
+    }
+    if (filter.priority && !['normal', 'high', 'urgent'].includes(filter.priority)) {
+        errors.push(`Invalid priority: "${filter.priority}". Must be "normal", "high", or "urgent"`);
+    }
+    if (filter.threadId !== undefined && filter.threadId !== null && typeof filter.threadId !== 'string') {
+        errors.push('threadId must be a string UUID or null');
+    }
+    return { valid: errors.length === 0, errors };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-filters.js","sourceRoot":"","sources":["../../src/core/query-filters.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,sCAAsC;;AA0QtC,sDAiBC;AArBD;;;GAGG;AACH,SAAgB,qBAAqB,CAAC,MAA8B;IAIlE,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,IAAI,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QACzF,MAAM,CAAC,IAAI,CAAC,yBAAyB,MAAM,CAAC,WAAW,6CAA6C,CAAC,CAAC;IACxG,CAAC;IACD,IAAI,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/E,MAAM,CAAC,IAAI,CAAC,sBAAsB,MAAM,CAAC,QAAQ,0CAA0C,CAAC,CAAC;IAC/F,CAAC;IACD,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACrG,MAAM,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;IACxD,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;AAChD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccessModifier } from '@pipeline-builder/api-core';\n\n/**\n * Base filter interface containing common filter properties shared across all entity types.\n *\n * @example\n * ```typescript\n * const filter: CommonFilter = {\n *   id: '123',\n *   orgId: 'my-org',\n *   accessModifier: AccessModifier.PUBLIC,\n *   isDefault: true,\n *   isActive: true\n * };\n * ```\n */\nexport interface CommonFilter {\n  /**\n   * Unique identifier for the entity\n   * Can be a single ID or array of IDs for batch filtering\n   */\n  readonly id?: string | string[];\n\n  /**\n   * Organization identifier to filter entities by organization\n   * Can be a single org ID or array for multi-org filtering\n   */\n  readonly orgId?: string | string[];\n\n  /**\n   * Access modifier to filter by visibility/permissions\n   * Use AccessModifier enum for type safety\n   * @see AccessModifier\n   */\n  readonly accessModifier?: AccessModifier | string;\n\n  /**\n   * Filter by default status\n   * - true: Only default entities\n   * - false: Only non-default entities\n   * - undefined: All entities\n   */\n  readonly isDefault?: boolean;\n\n  /**\n   * Filter by active/inactive status\n   * - true: Only active entities\n   * - false: Only inactive entities\n   * - undefined: All entities\n   */\n  readonly isActive?: boolean;\n\n  /**\n   * Number of results to return\n   * @minimum 1\n   * @maximum 1000\n   */\n  readonly limit?: number;\n\n  /**\n   * Number of results to skip (for pagination)\n   * @minimum 0\n   */\n  readonly offset?: number;\n\n  /**\n   * Sort field and direction\n   * @example \"name:asc\", \"createdAt:desc\"\n   */\n  readonly sort?: string;\n}\n\n/**\n * Filter interface for plugin-specific properties.\n * Extends CommonFilter to include plugin-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PluginFilter = {\n *   name: 'nodejs-build',\n *   version: '1.0.0',\n *   isActive: true\n * };\n * ```\n */\nexport interface PluginFilter extends CommonFilter {\n  /**\n   * Plugin name to filter by\n   */\n  readonly name?: string;\n\n  /**\n   * Plugin version to filter by\n   * Supports semantic versioning\n   * @example \"1.0.0\", \"^2.0.0\", \"~1.2.3\"\n   */\n  readonly version?: string;\n\n  /**\n   * Docker image tag associated with the plugin\n   */\n  readonly imageTag?: string;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n\n  /**\n   * Plugin category to filter by\n   * @example \"language\", \"security\", \"testing\"\n   */\n  readonly category?: string;\n}\n\n/**\n * Filter interface for pipeline-specific properties.\n * Extends CommonFilter to include pipeline-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PipelineFilter = {\n *   project: 'my-app',\n *   organization: 'my-org',\n *   pipelineName: 'my-pipeline',\n *   isActive: true\n * };\n * ```\n */\nexport interface PipelineFilter extends CommonFilter {\n  /**\n   * Project name associated with the pipeline\n   */\n  readonly project?: string;\n\n  /**\n   * Organization name associated with the pipeline\n   */\n  readonly organization?: string;\n\n  /**\n   * Pipeline name to filter by\n   */\n  readonly pipelineName?: string;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n}\n\n/**\n * Filter interface for message-specific properties.\n * Extends CommonFilter to include message-related filter options.\n */\nexport interface MessageFilter extends CommonFilter {\n  /**\n   * Thread ID to filter by (for fetching thread replies).\n   * Pass `null` to filter for root messages only (threadId IS NULL).\n   */\n  readonly threadId?: string | null;\n\n  /**\n   * Recipient organization ID to filter by\n   * Use '*' for broadcast announcements\n   */\n  readonly recipientOrgId?: string;\n\n  /**\n   * Message type filter\n   */\n  readonly messageType?: 'announcement' | 'conversation';\n\n  /**\n   * Filter by read status\n   */\n  readonly isRead?: boolean;\n\n  /**\n   * Filter by priority level\n   */\n  readonly priority?: 'normal' | 'high' | 'urgent';\n}\n\n// ========================================\n// Compliance Filters\n// ========================================\n\n/**\n * Filter for compliance policies.\n */\nexport interface CompliancePolicyFilter extends CommonFilter {\n  readonly name?: string;\n  readonly isTemplate?: boolean;\n}\n\n/**\n * Filter for compliance rules.\n */\nexport interface ComplianceRuleFilter extends CommonFilter {\n  readonly name?: string;\n  readonly policyId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly field?: string;\n  readonly severity?: 'warning' | 'error' | 'critical';\n  readonly scope?: 'org' | 'published';\n  readonly tag?: string;\n}\n\n/**\n * Filter for compliance rule subscriptions.\n */\nexport interface ComplianceRuleSubscriptionFilter {\n  readonly orgId?: string;\n  readonly ruleId?: string;\n  readonly isActive?: boolean;\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance exemptions.\n */\nexport interface ComplianceExemptionFilter {\n  readonly orgId?: string;\n  readonly ruleId?: string;\n  readonly entityType?: 'plugin' | 'pipeline';\n  readonly entityId?: string;\n  readonly status?: 'pending' | 'approved' | 'rejected' | 'expired';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance audit log entries.\n */\nexport interface ComplianceAuditFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly action?: string;\n  readonly result?: 'pass' | 'warn' | 'block';\n  readonly scanId?: string;\n  readonly dateFrom?: string;\n  readonly dateTo?: string;\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance scans.\n */\nexport interface ComplianceScanFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline' | 'all';\n  readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';\n  readonly triggeredBy?: 'manual' | 'scheduled' | 'rule-change' | 'rule-dry-run';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Validates message filter properties.\n * Returns a result object with `valid` flag and `errors` array.\n */\nexport function validateMessageFilter(filter: Partial<MessageFilter>): {\n  valid: boolean;\n  errors: string[];\n} {\n  const errors: string[] = [];\n\n  if (filter.messageType && !['announcement', 'conversation'].includes(filter.messageType)) {\n    errors.push(`Invalid messageType: \"${filter.messageType}\". Must be \"announcement\" or \"conversation\"`);\n  }\n  if (filter.priority && !['normal', 'high', 'urgent'].includes(filter.priority)) {\n    errors.push(`Invalid priority: \"${filter.priority}\". Must be \"normal\", \"high\", or \"urgent\"`);\n  }\n  if (filter.threadId !== undefined && filter.threadId !== null && typeof filter.threadId !== 'string') {\n    errors.push('threadId must be a string UUID or null');\n  }\n\n  return { valid: errors.length === 0, errors };\n}\n"]}