@pipeline-builder/api-server 4.1.21 → 4.1.23

package/lib/http/sse-ticket-broker.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Minting and redeeming the short-lived SSE tickets that authorize a log
+ * stream, plus the stream-ownership binding those mints are checked against.
+ *
+ * Separate from {@link SSEManager} because it shares nothing with the
+ * connection registry: its state lives entirely in the injected
+ * {@link SseTicketStore} (Redis in a multi-pod deploy), and every rule in here
+ * is an AUTHORIZATION rule — who may open which subject's stream — which is
+ * easier to audit as one unit than interleaved with connection bookkeeping.
+ */
+import { type SseTicketStore } from '@pipeline-builder/api-core';
+/** Result of {@link SseTicketBroker.createTicket}. */
+export type CreateTicketResult = {
+    ok: true;
+    ticket: string;
+} | {
+    ok: false;
+    reason: 'org-limit' | 'capacity' | 'forbidden';
+};
+export interface SseTicketBrokerOptions {
+    /** Ticket + stream-ownership backend. Defaults to an in-memory store (single
+     *  replica only), built on first use. Inject an api-core
+     *  `createEnvSseTicketStore(...)` so mint/redeem and stream ownership work
+     *  across pods. */
+    store?: SseTicketStore;
+    /** Cap on live tickets across the process, for the DEFAULT in-memory store.
+     *  Ignored when `store` is injected (the store carries its own caps). */
+    maxTotal?: number;
+    /** Per-org cap on live tickets, for the DEFAULT in-memory store. Ignored when
+     *  `store` is injected. */
+    maxPerOrg?: number;
+    /** Ticket TTL in ms for the default store. */
+    ttlMs?: number;
+    /** TTL for a stream-ownership binding (default 1h). Long enough to outlive a
+     *  build; the producer re-binds as needed. */
+    ownerTtlMs?: number;
+}
+/**
+ * Canonical form of a stream subject id for map/store keys: the id is allowed
+ * in two renderings (a dashed api-server uuid and nginx's undashed
+ * `$request_id`), and normalizing makes them compare equal. Callers are
+ * expected to have already format-validated against `SSE_REQUEST_ID_RE`.
+ */
+export declare function normalizeRequestId(requestId: string): string;
+/**
+ * Canonical form of an orgId for ownership equality checks: trimmed and
+ * lowercased. The stream PRODUCER (bindStreamOwner) and the ticket-minting
+ * CONSUMER (createTicket) run in different services, so a casing / whitespace
+ * drift between how each renders the same org would otherwise make the owner
+ * comparison in {@link SseTicketBroker.createTicket} false-`forbidden` the real
+ * owner. Normalizing both sides — mirroring {@link normalizeRequestId} — closes that.
+ */
+export declare function normalizeOrgId(orgId: string): string;
+export declare class SseTicketBroker {
+    private storeInstance?;
+    /** True when this broker built its store (so shutdown stops it). */
+    private ownsStore;
+    private readonly maxTotal;
+    private readonly maxPerOrg;
+    private readonly ttlMs;
+    private readonly ownerTtlMs;
+    constructor(options?: SseTicketBrokerOptions);
+    /** The ticket store, building the in-memory default on first use. */
+    private get store();
+    /**
+     * Record the org that OWNS a stream subject. The stream PRODUCER calls this
+     * when it creates a build-log stream so that ticket minting can assert the
+     * caller's org owns the subject (see {@link createTicket}). Backed by the
+     * injected ticket store, so when a Redis store is wired the platform producer
+     * (a different service sharing the same Redis) can bind ownership that this
+     * service reads — closing the cross-tenant attach gap where any org could mint
+     * a ticket for a guessed requestId.
+     *
+     * @param requestId - The stream subject (format-validated by the caller).
+     * @param orgId - The owning org (normalized internally via normalizeOrgId).
+     */
+    bindStreamOwner(requestId: string, orgId: string): Promise<void>;
+    /**
+     * Mint a short-lived, single-use SSE ticket bound to `orgId` AND a specific
+     * stream subject (`requestId`). Clients POST to obtain one (JWT-authenticated)
+     * for the exact stream they intend to open, then open the EventSource with
+     * `?ticket=<t>` so the JWT never lands in a query string / access log. The
+     * ticket can then only be consumed to open that one subject's stream — see
+     * {@link consumeTicket} — which is what enforces per-subject authorization.
+     *
+     * ORG-OWNERSHIP: if a stream owner has been bound for this subject (via
+     * {@link bindStreamOwner}) and it is a DIFFERENT org, minting is refused
+     * (`reason: 'forbidden'`) — an org cannot mint a ticket for another org's
+     * stream even if it guesses the requestId. When no owner is bound (producer
+     * wiring not yet present), minting falls back to binding the ticket to the
+     * caller's own org, preserving current behavior.
+     *
+     * Bounded by the ticket store's live-ticket caps (total and per org). An
+     * ownership lookup the store can't answer is refused as `capacity`.
+     *
+     * @param orgId - Owning org (normalized internally via normalizeOrgId).
+     * @param requestId - The build-log stream subject this ticket authorizes.
+     *   The caller must have format-validated it (see `SSE_REQUEST_ID_RE`).
+     * @returns `{ ok: true, ticket }` on success, or `{ ok: false, reason }`
+     *   where reason is `'org-limit'`, `'capacity'`, or `'forbidden'`.
+     */
+    createTicket(orgId: string, requestId: string): Promise<CreateTicketResult>;
+    /**
+     * Validate and CONSUME a ticket for a specific stream subject. Single-use:
+     * the ticket is deleted whether or not it turns out to be valid, so a replay
+     * of the same value always fails. Returns the bound org on success, or null
+     * when the ticket is unknown / already-used / expired / OR was minted for a
+     * DIFFERENT `requestId` than the one being opened.
+     *
+     * The subject check is the authorization fix: without it, a ticket minted for
+     * one stream could be presented to open ANY stream the holder's org could
+     * name, letting an authenticated org attach to another org's log stream by
+     * guessing its requestId. The generic 401 the caller returns does not
+     * distinguish "unknown ticket" from "wrong subject", so it leaks nothing
+     * about which requestIds exist.
+     *
+     * @param ticketId - The opaque ticket value from `?ticket=`.
+     * @param requestId - The stream subject from the URL path (`:requestId`),
+     *   already format-validated by the caller.
+     */
+    consumeTicket(ticketId: string, requestId: string): Promise<{
+        orgId: string;
+    } | null>;
+    /** Stop the store, but only the one this broker built — an injected store is
+     *  the caller's to close. */
+    shutdown(): void;
+}

package/lib/http/sse-ticket-broker.js

@@ -0,0 +1,170 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Minting and redeeming the short-lived SSE tickets that authorize a log
+ * stream, plus the stream-ownership binding those mints are checked against.
+ *
+ * Separate from {@link SSEManager} because it shares nothing with the
+ * connection registry: its state lives entirely in the injected
+ * {@link SseTicketStore} (Redis in a multi-pod deploy), and every rule in here
+ * is an AUTHORIZATION rule — who may open which subject's stream — which is
+ * easier to audit as one unit than interleaved with connection bookkeeping.
+ */
+import { createLogger, createMemorySseTicketStore, envSseTicketCaps, SSE_TICKET_TTL_MS, errorMessage } from '@pipeline-builder/api-core';
+import { incCounter } from '../api/metrics.js';
+const logger = createLogger('sse-tickets');
+/**
+ * Canonical form of a stream subject id for map/store keys: the id is allowed
+ * in two renderings (a dashed api-server uuid and nginx's undashed
+ * `$request_id`), and normalizing makes them compare equal. Callers are
+ * expected to have already format-validated against `SSE_REQUEST_ID_RE`.
+ */
+export function normalizeRequestId(requestId) {
+    return requestId.replace(/-/g, '').toLowerCase();
+}
+/**
+ * Canonical form of an orgId for ownership equality checks: trimmed and
+ * lowercased. The stream PRODUCER (bindStreamOwner) and the ticket-minting
+ * CONSUMER (createTicket) run in different services, so a casing / whitespace
+ * drift between how each renders the same org would otherwise make the owner
+ * comparison in {@link SseTicketBroker.createTicket} false-`forbidden` the real
+ * owner. Normalizing both sides — mirroring {@link normalizeRequestId} — closes that.
+ */
+export function normalizeOrgId(orgId) {
+    return orgId.trim().toLowerCase();
+}
+export class SseTicketBroker {
+    storeInstance;
+    /** True when this broker built its store (so shutdown stops it). */
+    ownsStore = false;
+    maxTotal;
+    maxPerOrg;
+    ttlMs;
+    ownerTtlMs;
+    constructor(options = {}) {
+        const caps = envSseTicketCaps();
+        this.maxTotal = options.maxTotal ?? caps.maxTotal;
+        this.maxPerOrg = options.maxPerOrg ?? caps.maxPerOrg;
+        this.ttlMs = options.ttlMs ?? SSE_TICKET_TTL_MS;
+        this.ownerTtlMs = options.ownerTtlMs ?? 3_600_000; // 1 hour
+        this.storeInstance = options.store;
+    }
+    /** The ticket store, building the in-memory default on first use. */
+    get store() {
+        if (!this.storeInstance) {
+            this.storeInstance = createMemorySseTicketStore({
+                ttlMs: this.ttlMs,
+                maxTotal: this.maxTotal,
+                maxPerOrg: this.maxPerOrg,
+            });
+            this.ownsStore = true;
+        }
+        return this.storeInstance;
+    }
+    /**
+     * Record the org that OWNS a stream subject. The stream PRODUCER calls this
+     * when it creates a build-log stream so that ticket minting can assert the
+     * caller's org owns the subject (see {@link createTicket}). Backed by the
+     * injected ticket store, so when a Redis store is wired the platform producer
+     * (a different service sharing the same Redis) can bind ownership that this
+     * service reads — closing the cross-tenant attach gap where any org could mint
+     * a ticket for a guessed requestId.
+     *
+     * @param requestId - The stream subject (format-validated by the caller).
+     * @param orgId - The owning org (normalized internally via normalizeOrgId).
+     */
+    async bindStreamOwner(requestId, orgId) {
+        await this.store.bindOwner(normalizeRequestId(requestId), normalizeOrgId(orgId), this.ownerTtlMs);
+    }
+    /**
+     * Mint a short-lived, single-use SSE ticket bound to `orgId` AND a specific
+     * stream subject (`requestId`). Clients POST to obtain one (JWT-authenticated)
+     * for the exact stream they intend to open, then open the EventSource with
+     * `?ticket=<t>` so the JWT never lands in a query string / access log. The
+     * ticket can then only be consumed to open that one subject's stream — see
+     * {@link consumeTicket} — which is what enforces per-subject authorization.
+     *
+     * ORG-OWNERSHIP: if a stream owner has been bound for this subject (via
+     * {@link bindStreamOwner}) and it is a DIFFERENT org, minting is refused
+     * (`reason: 'forbidden'`) — an org cannot mint a ticket for another org's
+     * stream even if it guesses the requestId. When no owner is bound (producer
+     * wiring not yet present), minting falls back to binding the ticket to the
+     * caller's own org, preserving current behavior.
+     *
+     * Bounded by the ticket store's live-ticket caps (total and per org). An
+     * ownership lookup the store can't answer is refused as `capacity`.
+     *
+     * @param orgId - Owning org (normalized internally via normalizeOrgId).
+     * @param requestId - The build-log stream subject this ticket authorizes.
+     *   The caller must have format-validated it (see `SSE_REQUEST_ID_RE`).
+     * @returns `{ ok: true, ticket }` on success, or `{ ok: false, reason }`
+     *   where reason is `'org-limit'`, `'capacity'`, or `'forbidden'`.
+     */
+    async createTicket(orgId, requestId) {
+        // Ownership gate first — a cross-tenant mint attempt should never even
+        // consume cap budget. Only enforced when an owner is actually bound. Both
+        // sides are org-normalized so a producer/consumer casing drift can't
+        // false-`forbidden` the real owner (mirrors requestId normalization).
+        const normalized = normalizeRequestId(requestId);
+        const normalizedOrg = normalizeOrgId(orgId);
+        let owner;
+        try {
+            owner = await this.store.getOwner(normalized);
+        }
+        catch (err) {
+            // Can't tell who owns the subject — refuse rather than mint unchecked.
+            logger.warn('SSE ticket refused: stream ownership lookup failed', { error: errorMessage(err) });
+            incCounter('sse_ticket_rejected_total', { reason: 'capacity' });
+            return { ok: false, reason: 'capacity' };
+        }
+        if (owner && owner !== normalizedOrg) {
+            logger.warn(`SSE ticket refused: org ${normalizedOrg} does not own stream subject`);
+            incCounter('sse_ticket_rejected_total', { reason: 'forbidden' });
+            return { ok: false, reason: 'forbidden' };
+        }
+        const issued = await this.store.issue(normalizedOrg, normalized);
+        if (!issued.ok) {
+            const reason = issued.reason === 'org' ? 'org-limit' : 'capacity';
+            logger.warn(`SSE ticket refused (${reason}) for ${normalizedOrg}`);
+            incCounter('sse_ticket_rejected_total', { reason });
+            return { ok: false, reason };
+        }
+        return { ok: true, ticket: issued.ticket };
+    }
+    /**
+     * Validate and CONSUME a ticket for a specific stream subject. Single-use:
+     * the ticket is deleted whether or not it turns out to be valid, so a replay
+     * of the same value always fails. Returns the bound org on success, or null
+     * when the ticket is unknown / already-used / expired / OR was minted for a
+     * DIFFERENT `requestId` than the one being opened.
+     *
+     * The subject check is the authorization fix: without it, a ticket minted for
+     * one stream could be presented to open ANY stream the holder's org could
+     * name, letting an authenticated org attach to another org's log stream by
+     * guessing its requestId. The generic 401 the caller returns does not
+     * distinguish "unknown ticket" from "wrong subject", so it leaks nothing
+     * about which requestIds exist.
+     *
+     * @param ticketId - The opaque ticket value from `?ticket=`.
+     * @param requestId - The stream subject from the URL path (`:requestId`),
+     *   already format-validated by the caller.
+     */
+    async consumeTicket(ticketId, requestId) {
+        const ticket = await this.store.consume(ticketId); // single-use
+        if (!ticket)
+            return null;
+        // Subject binding — reject a ticket presented for a subject it was not
+        // minted for (including an unbound, org-channel ticket). Both sides are
+        // normalized so dashed/undashed forms match.
+        if (ticket.subject !== normalizeRequestId(requestId))
+            return null;
+        return { orgId: ticket.orgId };
+    }
+    /** Stop the store, but only the one this broker built — an injected store is
+     *  the caller's to close. */
+    shutdown() {
+        if (this.ownsStore)
+            this.storeInstance?.stop();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-ticket-broker.js","sourceRoot":"","sources":["../../src/http/sse-ticket-broker.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Minting and redeeming the short-lived SSE tickets that authorize a log\n * stream, plus the stream-ownership binding those mints are checked against.\n *\n * Separate from {@link SSEManager} because it shares nothing with the\n * connection registry: its state lives entirely in the injected\n * {@link SseTicketStore} (Redis in a multi-pod deploy), and every rule in here\n * is an AUTHORIZATION rule — who may open which subject's stream — which is\n * easier to audit as one unit than interleaved with connection bookkeeping.\n */\n\nimport { createLogger, createMemorySseTicketStore, envSseTicketCaps, SSE_TICKET_TTL_MS, type SseTicketStore, errorMessage } from '@pipeline-builder/api-core';\nimport { incCounter } from '../api/metrics.js';\n\nconst logger = createLogger('sse-tickets');\n\n/** Result of {@link SseTicketBroker.createTicket}. */\nexport type CreateTicketResult =\n  | { ok: true; ticket: string }\n  | { ok: false; reason: 'org-limit' | 'capacity' | 'forbidden' };\n\nexport interface SseTicketBrokerOptions {\n  /** Ticket + stream-ownership backend. Defaults to an in-memory store (single\n   *  replica only), built on first use. Inject an api-core\n   *  `createEnvSseTicketStore(...)` so mint/redeem and stream ownership work\n   *  across pods. */\n  store?: SseTicketStore;\n  /** Cap on live tickets across the process, for the DEFAULT in-memory store.\n   *  Ignored when `store` is injected (the store carries its own caps). */\n  maxTotal?: number;\n  /** Per-org cap on live tickets, for the DEFAULT in-memory store. Ignored when\n   *  `store` is injected. */\n  maxPerOrg?: number;\n  /** Ticket TTL in ms for the default store. */\n  ttlMs?: number;\n  /** TTL for a stream-ownership binding (default 1h). Long enough to outlive a\n   *  build; the producer re-binds as needed. */\n  ownerTtlMs?: number;\n}\n\n/**\n * Canonical form of a stream subject id for map/store keys: the id is allowed\n * in two renderings (a dashed api-server uuid and nginx's undashed\n * `$request_id`), and normalizing makes them compare equal. Callers are\n * expected to have already format-validated against `SSE_REQUEST_ID_RE`.\n */\nexport function normalizeRequestId(requestId: string): string {\n  return requestId.replace(/-/g, '').toLowerCase();\n}\n\n/**\n * Canonical form of an orgId for ownership equality checks: trimmed and\n * lowercased. The stream PRODUCER (bindStreamOwner) and the ticket-minting\n * CONSUMER (createTicket) run in different services, so a casing / whitespace\n * drift between how each renders the same org would otherwise make the owner\n * comparison in {@link SseTicketBroker.createTicket} false-`forbidden` the real\n * owner. Normalizing both sides — mirroring {@link normalizeRequestId} — closes that.\n */\nexport function normalizeOrgId(orgId: string): string {\n  return orgId.trim().toLowerCase();\n}\n\nexport class SseTicketBroker {\n  private storeInstance?: SseTicketStore;\n  /** True when this broker built its store (so shutdown stops it). */\n  private ownsStore = false;\n  private readonly maxTotal: number;\n  private readonly maxPerOrg: number;\n  private readonly ttlMs: number;\n  private readonly ownerTtlMs: number;\n\n  constructor(options: SseTicketBrokerOptions = {}) {\n    const caps = envSseTicketCaps();\n    this.maxTotal = options.maxTotal ?? caps.maxTotal;\n    this.maxPerOrg = options.maxPerOrg ?? caps.maxPerOrg;\n    this.ttlMs = options.ttlMs ?? SSE_TICKET_TTL_MS;\n    this.ownerTtlMs = options.ownerTtlMs ?? 3_600_000; // 1 hour\n    this.storeInstance = options.store;\n  }\n\n  /** The ticket store, building the in-memory default on first use. */\n  private get store(): SseTicketStore {\n    if (!this.storeInstance) {\n      this.storeInstance = createMemorySseTicketStore({\n        ttlMs: this.ttlMs,\n        maxTotal: this.maxTotal,\n        maxPerOrg: this.maxPerOrg,\n      });\n      this.ownsStore = true;\n    }\n    return this.storeInstance;\n  }\n\n  /**\n   * Record the org that OWNS a stream subject. The stream PRODUCER calls this\n   * when it creates a build-log stream so that ticket minting can assert the\n   * caller's org owns the subject (see {@link createTicket}). Backed by the\n   * injected ticket store, so when a Redis store is wired the platform producer\n   * (a different service sharing the same Redis) can bind ownership that this\n   * service reads — closing the cross-tenant attach gap where any org could mint\n   * a ticket for a guessed requestId.\n   *\n   * @param requestId - The stream subject (format-validated by the caller).\n   * @param orgId - The owning org (normalized internally via normalizeOrgId).\n   */\n  async bindStreamOwner(requestId: string, orgId: string): Promise<void> {\n    await this.store.bindOwner(normalizeRequestId(requestId), normalizeOrgId(orgId), this.ownerTtlMs);\n  }\n\n  /**\n   * Mint a short-lived, single-use SSE ticket bound to `orgId` AND a specific\n   * stream subject (`requestId`). Clients POST to obtain one (JWT-authenticated)\n   * for the exact stream they intend to open, then open the EventSource with\n   * `?ticket=<t>` so the JWT never lands in a query string / access log. The\n   * ticket can then only be consumed to open that one subject's stream — see\n   * {@link consumeTicket} — which is what enforces per-subject authorization.\n   *\n   * ORG-OWNERSHIP: if a stream owner has been bound for this subject (via\n   * {@link bindStreamOwner}) and it is a DIFFERENT org, minting is refused\n   * (`reason: 'forbidden'`) — an org cannot mint a ticket for another org's\n   * stream even if it guesses the requestId. When no owner is bound (producer\n   * wiring not yet present), minting falls back to binding the ticket to the\n   * caller's own org, preserving current behavior.\n   *\n   * Bounded by the ticket store's live-ticket caps (total and per org). An\n   * ownership lookup the store can't answer is refused as `capacity`.\n   *\n   * @param orgId - Owning org (normalized internally via normalizeOrgId).\n   * @param requestId - The build-log stream subject this ticket authorizes.\n   *   The caller must have format-validated it (see `SSE_REQUEST_ID_RE`).\n   * @returns `{ ok: true, ticket }` on success, or `{ ok: false, reason }`\n   *   where reason is `'org-limit'`, `'capacity'`, or `'forbidden'`.\n   */\n  async createTicket(orgId: string, requestId: string): Promise<CreateTicketResult> {\n    // Ownership gate first — a cross-tenant mint attempt should never even\n    // consume cap budget. Only enforced when an owner is actually bound. Both\n    // sides are org-normalized so a producer/consumer casing drift can't\n    // false-`forbidden` the real owner (mirrors requestId normalization).\n    const normalized = normalizeRequestId(requestId);\n    const normalizedOrg = normalizeOrgId(orgId);\n    let owner: string | null;\n    try {\n      owner = await this.store.getOwner(normalized);\n    } catch (err) {\n      // Can't tell who owns the subject — refuse rather than mint unchecked.\n      logger.warn('SSE ticket refused: stream ownership lookup failed', { error: errorMessage(err) });\n      incCounter('sse_ticket_rejected_total', { reason: 'capacity' });\n      return { ok: false, reason: 'capacity' };\n    }\n    if (owner && owner !== normalizedOrg) {\n      logger.warn(`SSE ticket refused: org ${normalizedOrg} does not own stream subject`);\n      incCounter('sse_ticket_rejected_total', { reason: 'forbidden' });\n      return { ok: false, reason: 'forbidden' };\n    }\n\n    const issued = await this.store.issue(normalizedOrg, normalized);\n    if (!issued.ok) {\n      const reason = issued.reason === 'org' ? 'org-limit' : 'capacity';\n      logger.warn(`SSE ticket refused (${reason}) for ${normalizedOrg}`);\n      incCounter('sse_ticket_rejected_total', { reason });\n      return { ok: false, reason };\n    }\n    return { ok: true, ticket: issued.ticket };\n  }\n\n  /**\n   * Validate and CONSUME a ticket for a specific stream subject. Single-use:\n   * the ticket is deleted whether or not it turns out to be valid, so a replay\n   * of the same value always fails. Returns the bound org on success, or null\n   * when the ticket is unknown / already-used / expired / OR was minted for a\n   * DIFFERENT `requestId` than the one being opened.\n   *\n   * The subject check is the authorization fix: without it, a ticket minted for\n   * one stream could be presented to open ANY stream the holder's org could\n   * name, letting an authenticated org attach to another org's log stream by\n   * guessing its requestId. The generic 401 the caller returns does not\n   * distinguish \"unknown ticket\" from \"wrong subject\", so it leaks nothing\n   * about which requestIds exist.\n   *\n   * @param ticketId - The opaque ticket value from `?ticket=`.\n   * @param requestId - The stream subject from the URL path (`:requestId`),\n   *   already format-validated by the caller.\n   */\n  async consumeTicket(ticketId: string, requestId: string): Promise<{ orgId: string } | null> {\n    const ticket = await this.store.consume(ticketId); // single-use\n    if (!ticket) return null;\n    // Subject binding — reject a ticket presented for a subject it was not\n    // minted for (including an unbound, org-channel ticket). Both sides are\n    // normalized so dashed/undashed forms match.\n    if (ticket.subject !== normalizeRequestId(requestId)) return null;\n    return { orgId: ticket.orgId };\n  }\n\n  /** Stop the store, but only the one this broker built — an injected store is\n   *  the caller's to close. */\n  shutdown(): void {\n    if (this.ownsStore) this.storeInstance?.stop();\n  }\n}\n"]}

package/lib/testing/exports.json

@@ -8,6 +8,7 @@
       "connectMongo": "function",
       "createApp": "function",
       "createAuthenticatedWithOrgRoute": "function",
+      "createMetricHelpers": "function",
       "createProtectedRoute": "function",
       "createSharedRateLimitStore": "function",
       "currentTraceId": "function",

package/package.json

@@ -50,9 +50,9 @@
     "swagger-ui-express": "5.0.1",
     "unified": "11.0.5",
     "uuid": "14.0.2",
-    "@pipeline-builder/api-core": "4.1.19",
-    "@pipeline-builder/pipeline-data": "4.1.21",
-    "@pipeline-builder/pipeline-core": "4.1.21"
+    "@pipeline-builder/api-core": "4.1.21",
+    "@pipeline-builder/pipeline-data": "4.1.23",
+    "@pipeline-builder/pipeline-core": "4.1.23"
   },
   "keywords": [
     "ci-cd",
@@ -108,7 +108,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "4.1.21",
+  "version": "4.1.23",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },