@pipeline-builder/api-server 0.0.1

package/lib/api/metrics.js

@@ -0,0 +1,221 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Config } from '@pipeline-builder/pipeline-core';
+import { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';
+const SERVICE_NAME = Config.getAny('observability').serviceName;
+/** Shared Prometheus registry */
+const register = new Registry();
+// Set default labels for all metrics
+register.setDefaultLabels({ service: SERVICE_NAME });
+// Collect default Node.js process metrics (CPU, memory, heap, event loop lag, GC)
+collectDefaultMetrics({ register });
+/** HTTP request duration histogram (seconds) */
+const httpRequestDuration = new Histogram({
+    name: 'http_request_duration_seconds',
+    help: 'Duration of HTTP requests in seconds',
+    labelNames: ['method', 'route', 'status_code'],
+    buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
+    registers: [register],
+});
+/** HTTP request counter */
+const httpRequestsTotal = new Counter({
+    name: 'http_requests_total',
+    help: 'Total number of HTTP requests',
+    labelNames: ['method', 'route', 'status_code'],
+    registers: [register],
+});
+/**
+ * Per-org HTTP request counter — SAMPLED to keep Prometheus cardinality
+ * under control. Cardinality of `org_id * method * route * status_code`
+ * grows multiplicatively; with N orgs * 50 routes * 5 status_codes that's
+ * 250×N series. We sample 1-in-N requests (configurable via
+ * `HTTP_METRICS_ORG_SAMPLE_RATE`, default 1.0 = every request).
+ *
+ * Operators answer "what's org X's p99?" via separate per-org histograms
+ * scraped at a lower rate, OR via Loki LogQL queries against the
+ * unsampled access-log stream. This counter is the fast-path "noisy
+ * neighbor detection" — operators alert when one org's request rate
+ * deviates from the fleet median.
+ *
+ * NOT a histogram: histogram label cardinality is even more sensitive
+ * (each bucket is a separate series). If per-org latency percentiles are
+ * needed later, add a separate histogram with a coarser bucket set and
+ * lower sample rate.
+ */
+const httpRequestsByOrgTotal = new Counter({
+    name: 'http_requests_by_org_total',
+    help: 'Sampled per-org HTTP request count (sample rate via HTTP_METRICS_ORG_SAMPLE_RATE)',
+    labelNames: ['method', 'route', 'status_code', 'org_id'],
+    registers: [register],
+});
+/** Sample rate for the per-org counter. 1.0 = every request, 0.0 = disabled.
+ *  Parsed once at module load — operators tune by restarting the service. */
+const ORG_SAMPLE_RATE = (() => {
+    const raw = process.env.HTTP_METRICS_ORG_SAMPLE_RATE;
+    if (raw === undefined || raw === '')
+        return 1.0;
+    const parsed = parseFloat(raw);
+    if (Number.isNaN(parsed) || parsed < 0 || parsed > 1)
+        return 1.0;
+    return parsed;
+})();
+/**
+ * Normalize an Express route path to prevent label cardinality explosion.
+ *
+ * Uses Express's matched route pattern (e.g. `/plugins/:id`) when available,
+ * otherwise falls back to the raw path with UUID/numeric segments replaced.
+ */
+function normalizeRoute(req) {
+    // Prefer Express matched route pattern
+    if (req.route?.path) {
+        return req.baseUrl + req.route.path;
+    }
+    // Fallback: replace UUIDs and numeric IDs with :id
+    return req.path
+        .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, ':id')
+        .replace(/\/\d+(?=\/|$)/g, '/:id');
+}
+/**
+ * Express middleware that records request duration and count.
+ *
+ * Must be registered before route handlers so `res.on('finish')` fires
+ * after the response is sent.
+ */
+export function metricsMiddleware() {
+    return (req, res, next) => {
+        // NOTE: no /metrics or /health skip needed here — both endpoints are
+        // registered in app-factory BEFORE this middleware (createHealthRouter and
+        // app.get('/metrics') both terminate the response), so neither ever reaches
+        // this handler.
+        const end = httpRequestDuration.startTimer();
+        res.on('finish', () => {
+            const route = normalizeRoute(req);
+            const labels = {
+                method: req.method,
+                route,
+                status_code: String(res.statusCode),
+            };
+            end(labels);
+            httpRequestsTotal.inc(labels);
+            // Per-org sampled counter. Skip when:
+            //   - no org context on the request (anonymous / health endpoints)
+            //   - sample rate is 0 (disabled)
+            //   - dice roll fails
+            // Using Math.random for the sampler — for unbiased low-rate sampling
+            // a deterministic per-request hash would be more uniform, but at the
+            // default rate of 1.0 every request lands so this is fine.
+            const orgId = req.user?.organizationId;
+            if (orgId && ORG_SAMPLE_RATE > 0 && Math.random() < ORG_SAMPLE_RATE) {
+                httpRequestsByOrgTotal.inc({ ...labels, org_id: orgId });
+            }
+        });
+        next();
+    };
+}
+/**
+ * Express handler that returns Prometheus metrics in text exposition format.
+ */
+export function metricsHandler() {
+    return async (_req, res) => {
+        res.set('Content-Type', register.contentType);
+        res.end(await register.metrics());
+    };
+}
+// ---------------------------------------------------------------------------
+// Business / domain metrics
+//
+// Services should emit counters for the things operators actually care about
+// (pipelines generated, plugin builds completed, compliance violations,
+// AI tokens consumed) — not just HTTP traffic. The helpers below register
+// counters lazily on the shared registry so multiple services can call
+// `incCounter('plugin_builds_total', { status: 'completed' })` without
+// worrying about double-registration.
+//
+// Naming convention: `<domain>_<noun>_total` for counters, `_seconds` for
+// histograms — matches Prometheus best-practice.
+// ---------------------------------------------------------------------------
+const businessCounters = new Map();
+const businessHistograms = new Map();
+const businessGauges = new Map();
+/**
+ * Increment a business counter, creating it on first use.
+ *
+ * @example
+ * ```typescript
+ * incCounter('pipelines_generated_total', { provider: 'anthropic' });
+ * incCounter('plugin_builds_total', { status: 'completed' });
+ * incCounter('quota_threshold_crossed_total', { type: 'aiCalls', tier: 'pro' });
+ * incCounter('compliance_violations_found_total', { severity: 'critical' });
+ * ```
+ */
+export function incCounter(name, labels = {}, value = 1) {
+    let counter = businessCounters.get(name);
+    if (!counter) {
+        counter = new Counter({
+            name,
+            help: humanizeName(name),
+            labelNames: Object.keys(labels),
+            registers: [register],
+        });
+        businessCounters.set(name, counter);
+    }
+    counter.inc(labels, value);
+}
+/**
+ * Record an observation on a business histogram, creating it on first use.
+ * Use for durations, sizes, anything where percentiles matter.
+ *
+ * @example
+ * ```typescript
+ * observe('ai_generation_duration_seconds', { provider: 'anthropic', model: 'sonnet' }, durationSec);
+ * observe('plugin_build_duration_seconds', { buildType: 'docker' }, durationSec);
+ * ```
+ */
+export function observe(name, labels, value) {
+    let hist = businessHistograms.get(name);
+    if (!hist) {
+        hist = new Histogram({
+            name,
+            help: humanizeName(name),
+            labelNames: Object.keys(labels),
+            // Default buckets target sub-second through several-minute observations.
+            // Override by registering the histogram explicitly before first call
+            // if you need a different bucket distribution.
+            buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 300],
+            registers: [register],
+        });
+        businessHistograms.set(name, hist);
+    }
+    hist.observe(labels, value);
+}
+/**
+ * Set the value of a business gauge, creating it on first use. Use for
+ * point-in-time observations sampled by a scraper — queue depth, active
+ * connection counts, in-flight requests.
+ *
+ * @example
+ * ```typescript
+ * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'waiting' }, 12);
+ * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'active' }, 3);
+ * ```
+ */
+export function setGauge(name, labels, value) {
+    let gauge = businessGauges.get(name);
+    if (!gauge) {
+        gauge = new Gauge({
+            name,
+            help: humanizeName(name),
+            labelNames: Object.keys(labels),
+            registers: [register],
+        });
+        businessGauges.set(name, gauge);
+    }
+    gauge.set(labels, value);
+}
+function humanizeName(metricName) {
+    // `pipelines_generated_total` → "Pipelines generated total"
+    return metricName
+        .replace(/_/g, ' ')
+        .replace(/^./, (c) => c.toUpperCase());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metrics.js","sourceRoot":"","sources":["../../src/api/metrics.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Config } from '@pipeline-builder/pipeline-core';\nimport type { Request, Response, NextFunction } from 'express';\nimport { Registry, collectDefaultMetrics, Counter, Histogram, Gauge } from 'prom-client';\n\nconst SERVICE_NAME = (Config.getAny('observability') as { serviceName: string }).serviceName;\n\n/** Shared Prometheus registry */\nconst register = new Registry();\n\n// Set default labels for all metrics\nregister.setDefaultLabels({ service: SERVICE_NAME });\n\n// Collect default Node.js process metrics (CPU, memory, heap, event loop lag, GC)\ncollectDefaultMetrics({ register });\n\n/** HTTP request duration histogram (seconds) */\nconst httpRequestDuration = new Histogram({\n  name: 'http_request_duration_seconds',\n  help: 'Duration of HTTP requests in seconds',\n  labelNames: ['method', 'route', 'status_code'] as const,\n  buckets: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],\n  registers: [register],\n});\n\n/** HTTP request counter */\nconst httpRequestsTotal = new Counter({\n  name: 'http_requests_total',\n  help: 'Total number of HTTP requests',\n  labelNames: ['method', 'route', 'status_code'] as const,\n  registers: [register],\n});\n\n/**\n * Per-org HTTP request counter — SAMPLED to keep Prometheus cardinality\n * under control. Cardinality of `org_id * method * route * status_code`\n * grows multiplicatively; with N orgs * 50 routes * 5 status_codes that's\n * 250×N series. We sample 1-in-N requests (configurable via\n * `HTTP_METRICS_ORG_SAMPLE_RATE`, default 1.0 = every request).\n *\n * Operators answer \"what's org X's p99?\" via separate per-org histograms\n * scraped at a lower rate, OR via Loki LogQL queries against the\n * unsampled access-log stream. This counter is the fast-path \"noisy\n * neighbor detection\" — operators alert when one org's request rate\n * deviates from the fleet median.\n *\n * NOT a histogram: histogram label cardinality is even more sensitive\n * (each bucket is a separate series). If per-org latency percentiles are\n * needed later, add a separate histogram with a coarser bucket set and\n * lower sample rate.\n */\nconst httpRequestsByOrgTotal = new Counter({\n  name: 'http_requests_by_org_total',\n  help: 'Sampled per-org HTTP request count (sample rate via HTTP_METRICS_ORG_SAMPLE_RATE)',\n  labelNames: ['method', 'route', 'status_code', 'org_id'] as const,\n  registers: [register],\n});\n\n/** Sample rate for the per-org counter. 1.0 = every request, 0.0 = disabled.\n *  Parsed once at module load — operators tune by restarting the service. */\nconst ORG_SAMPLE_RATE = (() => {\n  const raw = process.env.HTTP_METRICS_ORG_SAMPLE_RATE;\n  if (raw === undefined || raw === '') return 1.0;\n  const parsed = parseFloat(raw);\n  if (Number.isNaN(parsed) || parsed < 0 || parsed > 1) return 1.0;\n  return parsed;\n})();\n\n/**\n * Normalize an Express route path to prevent label cardinality explosion.\n *\n * Uses Express's matched route pattern (e.g. `/plugins/:id`) when available,\n * otherwise falls back to the raw path with UUID/numeric segments replaced.\n */\nfunction normalizeRoute(req: Request): string {\n  // Prefer Express matched route pattern\n  if (req.route?.path) {\n    return req.baseUrl + req.route.path;\n  }\n\n  // Fallback: replace UUIDs and numeric IDs with :id\n  return req.path\n    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, ':id')\n    .replace(/\\/\\d+(?=\\/|$)/g, '/:id');\n}\n\n/**\n * Express middleware that records request duration and count.\n *\n * Must be registered before route handlers so `res.on('finish')` fires\n * after the response is sent.\n */\nexport function metricsMiddleware() {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    // NOTE: no /metrics or /health skip needed here — both endpoints are\n    // registered in app-factory BEFORE this middleware (createHealthRouter and\n    // app.get('/metrics') both terminate the response), so neither ever reaches\n    // this handler.\n    const end = httpRequestDuration.startTimer();\n\n    res.on('finish', () => {\n      const route = normalizeRoute(req);\n      const labels = {\n        method: req.method,\n        route,\n        status_code: String(res.statusCode),\n      };\n\n      end(labels);\n      httpRequestsTotal.inc(labels);\n\n      // Per-org sampled counter. Skip when:\n      //   - no org context on the request (anonymous / health endpoints)\n      //   - sample rate is 0 (disabled)\n      //   - dice roll fails\n      // Using Math.random for the sampler — for unbiased low-rate sampling\n      // a deterministic per-request hash would be more uniform, but at the\n      // default rate of 1.0 every request lands so this is fine.\n      const orgId = req.user?.organizationId;\n      if (orgId && ORG_SAMPLE_RATE > 0 && Math.random() < ORG_SAMPLE_RATE) {\n        httpRequestsByOrgTotal.inc({ ...labels, org_id: orgId });\n      }\n    });\n\n    next();\n  };\n}\n\n/**\n * Express handler that returns Prometheus metrics in text exposition format.\n */\nexport function metricsHandler() {\n  return async (_req: Request, res: Response): Promise<void> => {\n    res.set('Content-Type', register.contentType);\n    res.end(await register.metrics());\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Business / domain metrics\n//\n// Services should emit counters for the things operators actually care about\n// (pipelines generated, plugin builds completed, compliance violations,\n// AI tokens consumed) — not just HTTP traffic. The helpers below register\n// counters lazily on the shared registry so multiple services can call\n// `incCounter('plugin_builds_total', { status: 'completed' })` without\n// worrying about double-registration.\n//\n// Naming convention: `<domain>_<noun>_total` for counters, `_seconds` for\n// histograms — matches Prometheus best-practice.\n// ---------------------------------------------------------------------------\n\nconst businessCounters = new Map<string, Counter<string>>();\nconst businessHistograms = new Map<string, Histogram<string>>();\nconst businessGauges = new Map<string, Gauge<string>>();\n\n/**\n * Increment a business counter, creating it on first use.\n *\n * @example\n * ```typescript\n * incCounter('pipelines_generated_total', { provider: 'anthropic' });\n * incCounter('plugin_builds_total', { status: 'completed' });\n * incCounter('quota_threshold_crossed_total', { type: 'aiCalls', tier: 'pro' });\n * incCounter('compliance_violations_found_total', { severity: 'critical' });\n * ```\n */\nexport function incCounter(name: string, labels: Record<string, string> = {}, value = 1): void {\n  let counter = businessCounters.get(name);\n  if (!counter) {\n    counter = new Counter({\n      name,\n      help: humanizeName(name),\n      labelNames: Object.keys(labels),\n      registers: [register],\n    });\n    businessCounters.set(name, counter);\n  }\n  counter.inc(labels, value);\n}\n\n/**\n * Record an observation on a business histogram, creating it on first use.\n * Use for durations, sizes, anything where percentiles matter.\n *\n * @example\n * ```typescript\n * observe('ai_generation_duration_seconds', { provider: 'anthropic', model: 'sonnet' }, durationSec);\n * observe('plugin_build_duration_seconds', { buildType: 'docker' }, durationSec);\n * ```\n */\nexport function observe(name: string, labels: Record<string, string>, value: number): void {\n  let hist = businessHistograms.get(name);\n  if (!hist) {\n    hist = new Histogram({\n      name,\n      help: humanizeName(name),\n      labelNames: Object.keys(labels),\n      // Default buckets target sub-second through several-minute observations.\n      // Override by registering the histogram explicitly before first call\n      // if you need a different bucket distribution.\n      buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 300],\n      registers: [register],\n    });\n    businessHistograms.set(name, hist);\n  }\n  hist.observe(labels, value);\n}\n\n/**\n * Set the value of a business gauge, creating it on first use. Use for\n * point-in-time observations sampled by a scraper — queue depth, active\n * connection counts, in-flight requests.\n *\n * @example\n * ```typescript\n * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'waiting' }, 12);\n * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'active' }, 3);\n * ```\n */\nexport function setGauge(name: string, labels: Record<string, string>, value: number): void {\n  let gauge = businessGauges.get(name);\n  if (!gauge) {\n    gauge = new Gauge({\n      name,\n      help: humanizeName(name),\n      labelNames: Object.keys(labels),\n      registers: [register],\n    });\n    businessGauges.set(name, gauge);\n  }\n  gauge.set(labels, value);\n}\n\nfunction humanizeName(metricName: string): string {\n  // `pipelines_generated_total` → \"Pipelines generated total\"\n  return metricName\n    .replace(/_/g, ' ')\n    .replace(/^./, (c) => c.toUpperCase());\n}\n"]}

package/lib/api/middleware-factory.d.ts

@@ -0,0 +1,56 @@
+import type { QuotaType, QuotaService } from '@pipeline-builder/api-core';
+import type { RequestHandler } from 'express';
+/**
+ * Creates a middleware chain for protected routes requiring authentication, org ID, and quota check.
+ *
+ * Applies middleware in order:
+ * 1. requireAuth - Validates JWT and extracts user identity
+ * 2. requireOrgId - Ensures request has x-org-id header
+ * 3. idempotencyMiddleware - Dedupes keyed mutation retries (no-op without an
+ *    Idempotency-Key header or on non-mutation methods)
+ * 4. withTenantContext - Opens the RLS tenant scope (orgId + isSuperAdmin) for the request
+ * 5. checkQuota - Validates quota for the specified resource type
+ *
+ * Idempotency sits AFTER auth+orgId (so it can namespace the replay cache on the
+ * VERIFIED org — a pre-auth global mount saw no identity and was a permanent
+ * no-op) and BEFORE withTenantContext/checkQuota (so a replayed request short-
+ * circuits without opening an RLS scope or spending a quota check).
+ *
+ * @param quotaService - Quota service client
+ * @param quotaType - Which quota to check (e.g., 'apiCalls', 'pipelines', 'plugins')
+ * @returns Array of middleware handlers ready to spread into route definition
+ *
+ * @example
+ * ```typescript
+ * router.post('/',
+ *   ...createProtectedRoute(quotaService, 'pipelines'),
+ *   async (req, res) => {
+ *     // Handler implementation
+ *   }
+ * );
+ * ```
+ */
+export declare function createProtectedRoute(quotaService: QuotaService, quotaType: QuotaType): RequestHandler[];
+/**
+ * Creates a middleware chain for authenticated routes with org ID requirement but no quota check.
+ *
+ * Applies middleware in order:
+ * 1. requireAuth - Validates JWT and extracts user identity
+ * 2. requireOrgId - Ensures request has x-org-id header
+ * 3. withTenantContext - Opens the RLS tenant scope (orgId + isSuperAdmin) for the request
+ *
+ * Use this for read-only routes that don't consume quota.
+ *
+ * @returns Array of middleware handlers ready to spread into route definition
+ *
+ * @example
+ * ```typescript
+ * router.get('/',
+ *   ...createAuthenticatedWithOrgRoute(),
+ *   async (req, res) => {
+ *     // Handler implementation
+ *   }
+ * );
+ * ```
+ */
+export declare function createAuthenticatedWithOrgRoute(): RequestHandler[];

package/lib/api/middleware-factory.js

@@ -0,0 +1,80 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { checkQuota } from './check-quota.js';
+import { idempotencyMiddleware } from './idempotency-middleware.js';
+import { requireAuth } from './middleware.js';
+import { requireOrgId } from './require-org-id.js';
+import { withTenantContext } from './tenant-context.js';
+/**
+ * Creates a middleware chain for protected routes requiring authentication, org ID, and quota check.
+ *
+ * Applies middleware in order:
+ * 1. requireAuth - Validates JWT and extracts user identity
+ * 2. requireOrgId - Ensures request has x-org-id header
+ * 3. idempotencyMiddleware - Dedupes keyed mutation retries (no-op without an
+ *    Idempotency-Key header or on non-mutation methods)
+ * 4. withTenantContext - Opens the RLS tenant scope (orgId + isSuperAdmin) for the request
+ * 5. checkQuota - Validates quota for the specified resource type
+ *
+ * Idempotency sits AFTER auth+orgId (so it can namespace the replay cache on the
+ * VERIFIED org — a pre-auth global mount saw no identity and was a permanent
+ * no-op) and BEFORE withTenantContext/checkQuota (so a replayed request short-
+ * circuits without opening an RLS scope or spending a quota check).
+ *
+ * @param quotaService - Quota service client
+ * @param quotaType - Which quota to check (e.g., 'apiCalls', 'pipelines', 'plugins')
+ * @returns Array of middleware handlers ready to spread into route definition
+ *
+ * @example
+ * ```typescript
+ * router.post('/',
+ *   ...createProtectedRoute(quotaService, 'pipelines'),
+ *   async (req, res) => {
+ *     // Handler implementation
+ *   }
+ * );
+ * ```
+ */
+export function createProtectedRoute(quotaService, quotaType) {
+    return [
+        requireAuth,
+        requireOrgId(),
+        idempotencyMiddleware(),
+        withTenantContext(),
+        checkQuota(quotaService, quotaType),
+    ];
+}
+/**
+ * Creates a middleware chain for authenticated routes with org ID requirement but no quota check.
+ *
+ * Applies middleware in order:
+ * 1. requireAuth - Validates JWT and extracts user identity
+ * 2. requireOrgId - Ensures request has x-org-id header
+ * 3. withTenantContext - Opens the RLS tenant scope (orgId + isSuperAdmin) for the request
+ *
+ * Use this for read-only routes that don't consume quota.
+ *
+ * @returns Array of middleware handlers ready to spread into route definition
+ *
+ * @example
+ * ```typescript
+ * router.get('/',
+ *   ...createAuthenticatedWithOrgRoute(),
+ *   async (req, res) => {
+ *     // Handler implementation
+ *   }
+ * );
+ * ```
+ */
+export function createAuthenticatedWithOrgRoute() {
+    return [
+        requireAuth,
+        requireOrgId(),
+        // Mounted post-orgId (identity populated) so keyed mutation retries on the
+        // non-quota routes — notably the create paths, which use this factory to
+        // avoid the checkQuota pre-flight racing their reserve — are deduplicated.
+        idempotencyMiddleware(),
+        withTenantContext(),
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/middleware.d.ts

@@ -0,0 +1 @@
+export { requireAuth } from '@pipeline-builder/api-core';

package/lib/api/middleware.js

@@ -0,0 +1,8 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+// Convenience re-export: api-server consumers usually compose middleware
+// already imported from this package, so `requireAuth` is exposed here too.
+// Other auth middleware (requireFeature, requireSystemAdmin, isSystemAdmin) is
+// consumed directly from api-core where it's defined.
+export { requireAuth } from '@pipeline-builder/api-core';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hcGkvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLHlFQUF5RTtBQUN6RSw0RUFBNEU7QUFDNUUsK0VBQStFO0FBQy9FLHNEQUFzRDtBQUN0RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLy8gQ29udmVuaWVuY2UgcmUtZXhwb3J0OiBhcGktc2VydmVyIGNvbnN1bWVycyB1c3VhbGx5IGNvbXBvc2UgbWlkZGxld2FyZVxuLy8gYWxyZWFkeSBpbXBvcnRlZCBmcm9tIHRoaXMgcGFja2FnZSwgc28gYHJlcXVpcmVBdXRoYCBpcyBleHBvc2VkIGhlcmUgdG9vLlxuLy8gT3RoZXIgYXV0aCBtaWRkbGV3YXJlIChyZXF1aXJlRmVhdHVyZSwgcmVxdWlyZVN5c3RlbUFkbWluLCBpc1N5c3RlbUFkbWluKSBpc1xuLy8gY29uc3VtZWQgZGlyZWN0bHkgZnJvbSBhcGktY29yZSB3aGVyZSBpdCdzIGRlZmluZWQuXG5leHBvcnQgeyByZXF1aXJlQXV0aCB9IGZyb20gJ0BwaXBlbGluZS1idWlsZGVyL2FwaS1jb3JlJztcbiJdfQ==

package/lib/api/mongo-connect.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Minimal shape of mongoose accepted by `connectMongo`. Passing the real
+ * mongoose object satisfies it; api-server takes mongoose as a parameter
+ * (dependency injection) so it doesn't have to declare mongoose as a
+ * dependency itself.
+ */
+interface MongooseLike {
+    set(option: string, value: unknown): unknown;
+    connection: {
+        on(event: string, listener: (err?: Error) => void): unknown;
+    };
+    connect(uri: string, options: {
+        maxPoolSize: number;
+        minPoolSize: number;
+        serverSelectionTimeoutMS: number;
+    }): Promise<unknown>;
+}
+export declare function connectMongo(mongoose: MongooseLike, uri: string): Promise<void>;
+export {};

package/lib/api/mongo-connect.js

@@ -0,0 +1,41 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createLogger } from '@pipeline-builder/api-core';
+const logger = createLogger('mongo-connect');
+/**
+ * Connect to MongoDB with sensible production-ready pool defaults and
+ * standard event-handler wiring (error / disconnected / reconnected).
+ *
+ * Pool sizing is read from env (`MONGO_MAX_POOL`, `MONGO_MIN_POOL`,
+ * `MONGO_SERVER_SELECTION_MS`). Without these the driver default of
+ * `maxPoolSize=100` lets a burst exhaust Mongo's connection ceiling
+ * across replicas. Defaults: 20 max / 2 min / 5s server selection.
+ *
+ * Pass the service's own mongoose instance — api-server doesn't bundle
+ * mongoose itself.
+ */
+let handlersWired = false;
+export async function connectMongo(mongoose, uri) {
+    mongoose.set('strictQuery', true);
+    // Wire the connection event handlers exactly once. The startup supervisor
+    // may call connectMongo repeatedly (retrying until Mongo is reachable);
+    // re-registering on every attempt would leak listeners.
+    if (!handlersWired) {
+        handlersWired = true;
+        mongoose.connection.on('error', (err) => {
+            logger.error('MongoDB connection error', { error: err?.message });
+        });
+        mongoose.connection.on('disconnected', () => {
+            logger.warn('MongoDB disconnected');
+        });
+        mongoose.connection.on('reconnected', () => {
+            logger.info('MongoDB reconnected');
+        });
+    }
+    const maxPoolSize = parseInt(process.env.MONGO_MAX_POOL || '20', 10);
+    const minPoolSize = parseInt(process.env.MONGO_MIN_POOL || '2', 10);
+    const serverSelectionTimeoutMS = parseInt(process.env.MONGO_SERVER_SELECTION_MS || '5000', 10);
+    await mongoose.connect(uri, { maxPoolSize, minPoolSize, serverSelectionTimeoutMS });
+    logger.info('MongoDB connection established', { maxPoolSize, minPoolSize, serverSelectionTimeoutMS });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/quota-helpers.d.ts

@@ -0,0 +1,23 @@
+import { type QuotaService, type QuotaType } from '@pipeline-builder/api-core';
+import type { Request } from 'express';
+import type { RequestContext } from './request-types.js';
+/**
+ * Increment a quota counter using values pulled from a route context.
+ *
+ * Wraps `incrementQuota(quotaService, orgId, type, authHeader, logWarn)` so
+ * route handlers don't have to re-derive `req.headers.authorization` and
+ * `ctx.log.bind(null, 'WARN')` at every call site.
+ *
+ * @example
+ * ```typescript
+ * router.get('/', withRoute(async ({ req, res, ctx, orgId }) => {
+ *   // ...
+ *   incrementQuotaFromCtx(quotaService, { req, ctx, orgId }, 'apiCalls');
+ * }));
+ * ```
+ */
+export declare function incrementQuotaFromCtx(quotaService: QuotaService, rc: {
+    req: Request;
+    ctx: RequestContext;
+    orgId: string;
+}, type: QuotaType): void;

package/lib/api/quota-helpers.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { incrementQuota } from '@pipeline-builder/api-core';
+/**
+ * Increment a quota counter using values pulled from a route context.
+ *
+ * Wraps `incrementQuota(quotaService, orgId, type, authHeader, logWarn)` so
+ * route handlers don't have to re-derive `req.headers.authorization` and
+ * `ctx.log.bind(null, 'WARN')` at every call site.
+ *
+ * @example
+ * ```typescript
+ * router.get('/', withRoute(async ({ req, res, ctx, orgId }) => {
+ *   // ...
+ *   incrementQuotaFromCtx(quotaService, { req, ctx, orgId }, 'apiCalls');
+ * }));
+ * ```
+ */
+export function incrementQuotaFromCtx(quotaService, rc, type) {
+    incrementQuota(quotaService, rc.orgId, type, rc.req.headers.authorization || '', rc.ctx.log.bind(null, 'WARN'));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/rate-limit-by-org.d.ts

@@ -0,0 +1,29 @@
+/** Config for a {@link rateLimitByOrg} limiter. */
+export interface OrgRateLimitOptions {
+    /** Unique name — namespaces the Redis bucket + labels logs. */
+    name: string;
+    /** Max requests per window per org (or per client IP when unauthenticated). */
+    max: number;
+    /** Window length in ms. */
+    windowMs: number;
+    /** Optional 429 message override. */
+    message?: string;
+}
+/**
+ * Per-ORGANIZATION rate limiter for a specific hot/expensive route, keyed on the
+ * VERIFIED auth org — the complement to the coarse global per-IP limiter in
+ * `createApp` (which a whole org behind one NAT shares, and a distributed
+ * attacker spreads across IP buckets to evade).
+ *
+ * MUST be mounted AFTER `requireAuth` so `req.user.organizationId` is populated;
+ * an unauthenticated caller falls back to a client-IP bucket (never a spoofable
+ * header) so it stays bounded. Verified internal service principals are exempt
+ * (they carry a signed service JWT). Uses the shared env Redis store
+ * (cross-replica, namespaced by `name`) when configured, else in-memory.
+ *
+ * @example
+ *   router.post('/', ...createAuthenticatedWithOrgRoute(), requirePermission('messages:write'),
+ *     rateLimitByOrg({ name: 'message-send', max: 60, windowMs: 60_000 }),
+ *     withRoute(handler));
+ */
+export declare function rateLimitByOrg(opts: OrgRateLimitOptions): import("express-rate-limit").RateLimitRequestHandler;