@pipeline-builder/api-core 3.1.0

package/lib/services/quota.d.ts

@@ -0,0 +1,59 @@
+import { QuotaType, QuotaCheckResult } from '../types/common';
+/**
+ * Quota service client interface.
+ */
+export interface QuotaService {
+    /** Check if quota is available (fail-open on error). */
+    check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;
+    /** Increment quota usage. Returns a promise so callers can optionally handle errors. */
+    increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<void>;
+    /** Update quota limits. Returns true on success. */
+    updateLimits(orgId: string, limits: Partial<Record<QuotaType, number>>, authHeader: string, requestId?: string): Promise<boolean>;
+    /** Reset quota usage. Returns true on success. */
+    reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean>;
+}
+/**
+ * Configuration for quota service client.
+ */
+export interface QuotaServiceConfig {
+    /** Quota service host (default: env QUOTA_SERVICE_HOST or 'quota') */
+    host?: string;
+    /** Quota service port (default: env QUOTA_SERVICE_PORT or 3000) */
+    port?: number;
+    /** Request timeout in milliseconds (default: 5000) */
+    timeout?: number;
+}
+/**
+ * Create a quota service client.
+ *
+ * @param config - Optional service configuration
+ * @returns Quota service client
+ *
+ * @example
+ * ```typescript
+ * const quotaService = createQuotaService();
+ *
+ * // Check quota before processing
+ * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);
+ * if (!quota.allowed) {
+ *   return res.status(429).json({ error: 'Quota exceeded' });
+ * }
+ *
+ * // Increment quota after success
+ * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));
+ * ```
+ */
+export declare function createQuotaService(config?: QuotaServiceConfig): QuotaService;
+/**
+ * Fire-and-forget quota increment with standardized error logging.
+ *
+ * Wraps `quotaService.increment()` with a `.catch()` that logs a warning.
+ * Eliminates the identical one-liner repeated across every read route.
+ *
+ * @param quotaService - Quota service client
+ * @param orgId - Organization ID
+ * @param quotaType - Quota type to increment
+ * @param authHeader - Authorization header value
+ * @param logWarn - Logging function for warnings
+ */
+export declare function incrementQuota(quotaService: QuotaService, orgId: string, quotaType: QuotaType, authHeader: string, logWarn: (message: string, data?: unknown) => void): void;

package/lib/services/quota.js

@@ -0,0 +1,137 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQuotaService = createQuotaService;
+exports.incrementQuota = incrementQuota;
+const http_client_1 = require("./http-client");
+const logger_1 = require("../utils/logger");
+/** Retry options for quota calls — fail fast since quota is fail-open. */
+const QUOTA_REQUEST_OPTIONS = {
+    maxRateLimitRetries: 1,
+    maxRetries: 1,
+};
+const logger = (0, logger_1.createLogger)('quota');
+/**
+ * Create a fail-open quota result (allows the request).
+ */
+function createFailOpenResult() {
+    return {
+        allowed: true,
+        limit: -1,
+        used: 0,
+        remaining: -1,
+        resetAt: new Date().toISOString(),
+        unlimited: true,
+    };
+}
+/**
+ * Build common request headers with optional request ID for distributed tracing.
+ */
+function buildHeaders(orgId, authHeader, requestId) {
+    const headers = { 'x-org-id': orgId };
+    if (authHeader)
+        headers.Authorization = authHeader;
+    if (requestId)
+        headers['X-Request-Id'] = requestId;
+    return headers;
+}
+/**
+ * Create a quota service client.
+ *
+ * @param config - Optional service configuration
+ * @returns Quota service client
+ *
+ * @example
+ * ```typescript
+ * const quotaService = createQuotaService();
+ *
+ * // Check quota before processing
+ * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);
+ * if (!quota.allowed) {
+ *   return res.status(429).json({ error: 'Quota exceeded' });
+ * }
+ *
+ * // Increment quota after success
+ * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));
+ * ```
+ */
+function createQuotaService(config = {}) {
+    const serviceConfig = {
+        host: config.host ?? process.env.QUOTA_SERVICE_HOST ?? 'quota',
+        port: config.port ?? parseInt(process.env.QUOTA_SERVICE_PORT ?? '3000', 10),
+        timeout: config.timeout ?? 5000,
+    };
+    const client = (0, http_client_1.createSafeClient)(serviceConfig);
+    return {
+        async check(orgId, quotaType, authHeader, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;
+            const response = await client.get(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (!response) {
+                logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });
+                return createFailOpenResult();
+            }
+            if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {
+                logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {
+                    orgId, quotaType, statusCode: response.statusCode, message: response.body.message,
+                });
+                return createFailOpenResult();
+            }
+            return response.body.data.status;
+        },
+        async increment(orgId, quotaType, authHeader, amount = 1, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/increment`;
+            const response = await client
+                .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });
+            if (!response || response.statusCode !== 200) {
+                logger.warn('Failed to increment quota', {
+                    orgId, quotaType, amount, statusCode: response?.statusCode,
+                });
+            }
+            else {
+                logger.debug('Quota incremented', { orgId, quotaType, amount });
+            }
+        },
+        async updateLimits(orgId, limits, authHeader, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}`;
+            const response = await client.put(path, limits, { headers: buildHeaders(orgId, authHeader, requestId) });
+            if (!response || response.statusCode !== 200) {
+                logger.warn('Failed to update quota limits', {
+                    orgId, limits, statusCode: response?.statusCode,
+                });
+                return false;
+            }
+            logger.info('Quota limits updated', { orgId, limits });
+            return true;
+        },
+        async reset(orgId, quotaType, authHeader, requestId) {
+            const path = `/quotas/${encodeURIComponent(orgId)}/reset`;
+            const body = quotaType ? { quotaType } : {};
+            const response = await client.post(path, body, { headers: buildHeaders(orgId, authHeader ?? '', requestId) });
+            if (!response || response.statusCode !== 200) {
+                logger.warn('Failed to reset quota', {
+                    orgId, quotaType, statusCode: response?.statusCode,
+                });
+                return false;
+            }
+            logger.info('Quota reset', { orgId, quotaType: quotaType ?? 'all' });
+            return true;
+        },
+    };
+}
+/**
+ * Fire-and-forget quota increment with standardized error logging.
+ *
+ * Wraps `quotaService.increment()` with a `.catch()` that logs a warning.
+ * Eliminates the identical one-liner repeated across every read route.
+ *
+ * @param quotaService - Quota service client
+ * @param orgId - Organization ID
+ * @param quotaType - Quota type to increment
+ * @param authHeader - Authorization header value
+ * @param logWarn - Logging function for warnings
+ */
+function incrementQuota(quotaService, orgId, quotaType, authHeader, logWarn) {
+    quotaService.increment(orgId, quotaType, authHeader).catch((err) => logWarn('Quota increment failed', { error: err instanceof Error ? err.message : String(err) }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota.js","sourceRoot":"","sources":["../../src/services/quota.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createSafeClient, RequestOptions } from './http-client';\nimport { QuotaType, QuotaCheckResult, ServiceConfig } from '../types/common';\nimport { createLogger } from '../utils/logger';\n\n/** Retry options for quota calls — fail fast since quota is fail-open. */\nconst QUOTA_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 1,\n  maxRetries: 1,\n};\n\nconst logger = createLogger('quota');\n\n/**\n * Quota service client interface.\n */\nexport interface QuotaService {\n  /** Check if quota is available (fail-open on error). */\n  check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult>;\n  /** Increment quota usage. Returns a promise so callers can optionally handle errors. */\n  increment(orgId: string, quotaType: QuotaType, authHeader: string, amount?: number, requestId?: string): Promise<void>;\n  /** Update quota limits. Returns true on success. */\n  updateLimits(orgId: string, limits: Partial<Record<QuotaType, number>>, authHeader: string, requestId?: string): Promise<boolean>;\n  /** Reset quota usage. Returns true on success. */\n  reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean>;\n}\n\n/**\n * Configuration for quota service client.\n */\nexport interface QuotaServiceConfig {\n  /** Quota service host (default: env QUOTA_SERVICE_HOST or 'quota') */\n  host?: string;\n  /** Quota service port (default: env QUOTA_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout in milliseconds (default: 5000) */\n  timeout?: number;\n}\n\n/**\n * Create a fail-open quota result (allows the request).\n */\nfunction createFailOpenResult(): QuotaCheckResult {\n  return {\n    allowed: true,\n    limit: -1,\n    used: 0,\n    remaining: -1,\n    resetAt: new Date().toISOString(),\n    unlimited: true,\n  };\n}\n\n/**\n * Build common request headers with optional request ID for distributed tracing.\n */\nfunction buildHeaders(orgId: string, authHeader?: string, requestId?: string): Record<string, string> {\n  const headers: Record<string, string> = { 'x-org-id': orgId };\n  if (authHeader) headers.Authorization = authHeader;\n  if (requestId) headers['X-Request-Id'] = requestId;\n  return headers;\n}\n\n/**\n * Create a quota service client.\n *\n * @param config - Optional service configuration\n * @returns Quota service client\n *\n * @example\n * ```typescript\n * const quotaService = createQuotaService();\n *\n * // Check quota before processing\n * const quota = await quotaService.check(orgId, 'apiCalls', authHeader);\n * if (!quota.allowed) {\n *   return res.status(429).json({ error: 'Quota exceeded' });\n * }\n *\n * // Increment quota after success\n * quotaService.increment(orgId, 'apiCalls', authHeader).catch(err => logger.warn('Quota increment failed', { error: err }));\n * ```\n */\nexport function createQuotaService(config: QuotaServiceConfig = {}): QuotaService {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? process.env.QUOTA_SERVICE_HOST ?? 'quota',\n    port: config.port ?? parseInt(process.env.QUOTA_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 5000,\n  };\n\n  const client = createSafeClient(serviceConfig);\n\n  return {\n    async check(orgId: string, quotaType: QuotaType, authHeader: string, requestId?: string): Promise<QuotaCheckResult> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/${encodeURIComponent(quotaType)}`;\n\n      const response = await client.get<{\n        success: boolean;\n        data?: { quotaType: string; status: QuotaCheckResult };\n        message?: string;\n      }>(path, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota service unreachable, allowing request', { orgId, quotaType });\n        return createFailOpenResult();\n      }\n\n      if (response.statusCode !== 200 || !response.body.success || !response.body.data?.status) {\n        logger.warn('QUOTA_FAIL_OPEN: Quota check returned non-ok, allowing request', {\n          orgId, quotaType, statusCode: response.statusCode, message: response.body.message,\n        });\n        return createFailOpenResult();\n      }\n\n      return response.body.data.status;\n    },\n\n    async increment(orgId: string, quotaType: QuotaType, authHeader: string, amount: number = 1, requestId?: string): Promise<void> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/increment`;\n\n      const response = await client\n        .post(path, { quotaType, amount }, { headers: buildHeaders(orgId, authHeader, requestId), ...QUOTA_REQUEST_OPTIONS });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to increment quota', {\n          orgId, quotaType, amount, statusCode: response?.statusCode,\n        });\n      } else {\n        logger.debug('Quota incremented', { orgId, quotaType, amount });\n      }\n    },\n\n    async updateLimits(\n      orgId: string,\n      limits: Partial<Record<QuotaType, number>>,\n      authHeader: string,\n      requestId?: string,\n    ): Promise<boolean> {\n      const path = `/quotas/${encodeURIComponent(orgId)}`;\n\n      const response = await client.put(path, limits, { headers: buildHeaders(orgId, authHeader, requestId) });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to update quota limits', {\n          orgId, limits, statusCode: response?.statusCode,\n        });\n        return false;\n      }\n\n      logger.info('Quota limits updated', { orgId, limits });\n      return true;\n    },\n\n    async reset(orgId: string, quotaType?: QuotaType, authHeader?: string, requestId?: string): Promise<boolean> {\n      const path = `/quotas/${encodeURIComponent(orgId)}/reset`;\n\n      const body = quotaType ? { quotaType } : {};\n      const response = await client.post(path, body, { headers: buildHeaders(orgId, authHeader ?? '', requestId) });\n\n      if (!response || response.statusCode !== 200) {\n        logger.warn('Failed to reset quota', {\n          orgId, quotaType, statusCode: response?.statusCode,\n        });\n        return false;\n      }\n\n      logger.info('Quota reset', { orgId, quotaType: quotaType ?? 'all' });\n      return true;\n    },\n  };\n}\n\n/**\n * Fire-and-forget quota increment with standardized error logging.\n *\n * Wraps `quotaService.increment()` with a `.catch()` that logs a warning.\n * Eliminates the identical one-liner repeated across every read route.\n *\n * @param quotaService - Quota service client\n * @param orgId - Organization ID\n * @param quotaType - Quota type to increment\n * @param authHeader - Authorization header value\n * @param logWarn - Logging function for warnings\n */\nexport function incrementQuota(\n  quotaService: QuotaService,\n  orgId: string,\n  quotaType: QuotaType,\n  authHeader: string,\n  logWarn: (message: string, data?: unknown) => void,\n): void {\n  quotaService.increment(orgId, quotaType, authHeader).catch((err: unknown) =>\n    logWarn('Quota increment failed', { error: err instanceof Error ? err.message : String(err) }),\n  );\n}\n"]}

package/lib/services/retry-strategy.d.ts

@@ -0,0 +1,74 @@
+import * as http from 'http';
+/**
+ * Default retry configuration (env: `HTTP_CLIENT_MAX_RETRIES`, `HTTP_CLIENT_RETRY_DELAY_MS`).
+ */
+export declare const DEFAULT_MAX_RETRIES: number;
+export declare const DEFAULT_RETRY_DELAY_MS: number;
+export declare const DEFAULT_MAX_RATE_LIMIT_RETRIES: number;
+/**
+ * Configuration for retry behavior.
+ */
+export interface RetryConfig {
+    /** Maximum retry attempts for transient failures (default: 2) */
+    maxRetries: number;
+    /** Base delay between retries in ms — doubles each attempt (default: 200) */
+    retryDelayMs: number;
+    /** Maximum retry attempts specifically for 429 rate limiting (default: 4) */
+    maxRateLimitRetries: number;
+}
+/**
+ * Result of a retry decision: whether to retry, and how long to wait.
+ */
+export interface RetryDecision {
+    /** Whether the request should be retried */
+    shouldRetry: boolean;
+    /** Delay in milliseconds before retrying (with jitter applied) */
+    delayMs: number;
+    /** Human-readable reason for the retry decision */
+    reason: string;
+}
+/**
+ * Parse a `Retry-After` header value into milliseconds.
+ * Supports numeric seconds (e.g. "5") and HTTP-date format.
+ * Returns `undefined` for missing or invalid values.
+ */
+export declare function parseRetryAfter(header: string | string[] | undefined): number | undefined;
+/**
+ * Apply +/-25% random jitter to a delay to prevent thundering herd.
+ */
+export declare function addJitter(delay: number): number;
+/**
+ * Calculate exponential backoff delay for a given attempt.
+ *
+ * @param baseDelay - Base delay in milliseconds
+ * @param attempt - Zero-based attempt number
+ * @returns Delay in milliseconds (without jitter)
+ */
+export declare function calculateBackoff(baseDelay: number, attempt: number): number;
+/**
+ * Determine whether a status code represents a transient server error
+ * that is eligible for retry (502, 503, 504).
+ */
+export declare function isTransientStatusCode(statusCode: number): boolean;
+/**
+ * Determine whether a status code indicates rate limiting (429).
+ */
+export declare function isRateLimited(statusCode: number): boolean;
+/**
+ * Determine whether a failed response should be retried, and compute the delay.
+ *
+ * @param statusCode - HTTP status code of the response
+ * @param headers - Response headers (used to read Retry-After for 429)
+ * @param attempt - Zero-based attempt number
+ * @param config - Retry configuration
+ * @returns A RetryDecision indicating whether to retry and the delay
+ */
+export declare function getRetryDecision(statusCode: number, headers: http.IncomingHttpHeaders, attempt: number, config: RetryConfig): RetryDecision;
+/**
+ * Determine whether a connection/timeout error should be retried, and compute the delay.
+ *
+ * @param attempt - Zero-based attempt number
+ * @param config - Retry configuration
+ * @returns A RetryDecision indicating whether to retry and the delay
+ */
+export declare function getErrorRetryDecision(attempt: number, config: RetryConfig): RetryDecision;

package/lib/services/retry-strategy.js

@@ -0,0 +1,127 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_RATE_LIMIT_RETRIES = exports.DEFAULT_RETRY_DELAY_MS = exports.DEFAULT_MAX_RETRIES = void 0;
+exports.parseRetryAfter = parseRetryAfter;
+exports.addJitter = addJitter;
+exports.calculateBackoff = calculateBackoff;
+exports.isTransientStatusCode = isTransientStatusCode;
+exports.isRateLimited = isRateLimited;
+exports.getRetryDecision = getRetryDecision;
+exports.getErrorRetryDecision = getErrorRetryDecision;
+/**
+ * Default retry configuration (env: `HTTP_CLIENT_MAX_RETRIES`, `HTTP_CLIENT_RETRY_DELAY_MS`).
+ */
+exports.DEFAULT_MAX_RETRIES = parseInt(process.env.HTTP_CLIENT_MAX_RETRIES || '2', 10);
+exports.DEFAULT_RETRY_DELAY_MS = parseInt(process.env.HTTP_CLIENT_RETRY_DELAY_MS || '200', 10);
+exports.DEFAULT_MAX_RATE_LIMIT_RETRIES = parseInt(process.env.HTTP_CLIENT_MAX_RATE_LIMIT_RETRIES || '4', 10);
+/** Max Retry-After value we'll honor (60 seconds). */
+const MAX_RETRY_AFTER_MS = 60_000;
+/** HTTP status codes considered transient server errors eligible for retry. */
+const TRANSIENT_STATUS_CODES = [502, 503, 504];
+/**
+ * Parse a `Retry-After` header value into milliseconds.
+ * Supports numeric seconds (e.g. "5") and HTTP-date format.
+ * Returns `undefined` for missing or invalid values.
+ */
+function parseRetryAfter(header) {
+    if (!header)
+        return undefined;
+    const value = Array.isArray(header) ? header[0] : header;
+    if (!value)
+        return undefined;
+    // Try numeric seconds first
+    const seconds = Number(value);
+    if (!isNaN(seconds) && seconds >= 0) {
+        return Math.min(seconds * 1000, MAX_RETRY_AFTER_MS);
+    }
+    // Try HTTP-date
+    const date = Date.parse(value);
+    if (!isNaN(date)) {
+        const delayMs = date - Date.now();
+        if (delayMs > 0)
+            return Math.min(delayMs, MAX_RETRY_AFTER_MS);
+    }
+    return undefined;
+}
+/**
+ * Apply +/-25% random jitter to a delay to prevent thundering herd.
+ */
+function addJitter(delay) {
+    const jitter = delay * 0.25 * (2 * Math.random() - 1); // -25% to +25%
+    return Math.max(0, Math.round(delay + jitter));
+}
+/**
+ * Calculate exponential backoff delay for a given attempt.
+ *
+ * @param baseDelay - Base delay in milliseconds
+ * @param attempt - Zero-based attempt number
+ * @returns Delay in milliseconds (without jitter)
+ */
+function calculateBackoff(baseDelay, attempt) {
+    return baseDelay * Math.pow(2, attempt);
+}
+/**
+ * Determine whether a status code represents a transient server error
+ * that is eligible for retry (502, 503, 504).
+ */
+function isTransientStatusCode(statusCode) {
+    return TRANSIENT_STATUS_CODES.includes(statusCode);
+}
+/**
+ * Determine whether a status code indicates rate limiting (429).
+ */
+function isRateLimited(statusCode) {
+    return statusCode === 429;
+}
+/**
+ * Determine whether a failed response should be retried, and compute the delay.
+ *
+ * @param statusCode - HTTP status code of the response
+ * @param headers - Response headers (used to read Retry-After for 429)
+ * @param attempt - Zero-based attempt number
+ * @param config - Retry configuration
+ * @returns A RetryDecision indicating whether to retry and the delay
+ */
+function getRetryDecision(statusCode, headers, attempt, config) {
+    // 429 rate limiting — use Retry-After or longer backoff (4x base)
+    if (isRateLimited(statusCode) && attempt < config.maxRateLimitRetries) {
+        const retryAfter = parseRetryAfter(headers['retry-after']);
+        const rawDelay = retryAfter ?? (config.retryDelayMs * 4 * Math.pow(2, attempt));
+        return {
+            shouldRetry: true,
+            delayMs: addJitter(rawDelay),
+            reason: 'Rate limited (429)',
+        };
+    }
+    // 5xx transient server errors — standard exponential backoff
+    if (isTransientStatusCode(statusCode) && attempt < config.maxRetries) {
+        const rawDelay = calculateBackoff(config.retryDelayMs, attempt);
+        return {
+            shouldRetry: true,
+            delayMs: addJitter(rawDelay),
+            reason: `Transient server error (${statusCode})`,
+        };
+    }
+    return { shouldRetry: false, delayMs: 0, reason: 'Not retryable' };
+}
+/**
+ * Determine whether a connection/timeout error should be retried, and compute the delay.
+ *
+ * @param attempt - Zero-based attempt number
+ * @param config - Retry configuration
+ * @returns A RetryDecision indicating whether to retry and the delay
+ */
+function getErrorRetryDecision(attempt, config) {
+    if (attempt < config.maxRetries) {
+        const rawDelay = calculateBackoff(config.retryDelayMs, attempt);
+        return {
+            shouldRetry: true,
+            delayMs: addJitter(rawDelay),
+            reason: 'Connection or timeout error',
+        };
+    }
+    return { shouldRetry: false, delayMs: 0, reason: 'Max retries exceeded' };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retry-strategy.js","sourceRoot":"","sources":["../../src/services/retry-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as http from 'http';\n\n/**\n * Default retry configuration (env: `HTTP_CLIENT_MAX_RETRIES`, `HTTP_CLIENT_RETRY_DELAY_MS`).\n */\nexport const DEFAULT_MAX_RETRIES = parseInt(process.env.HTTP_CLIENT_MAX_RETRIES || '2', 10);\nexport const DEFAULT_RETRY_DELAY_MS = parseInt(process.env.HTTP_CLIENT_RETRY_DELAY_MS || '200', 10);\nexport const DEFAULT_MAX_RATE_LIMIT_RETRIES = parseInt(process.env.HTTP_CLIENT_MAX_RATE_LIMIT_RETRIES || '4', 10);\n\n/** Max Retry-After value we'll honor (60 seconds). */\nconst MAX_RETRY_AFTER_MS = 60_000;\n\n/** HTTP status codes considered transient server errors eligible for retry. */\nconst TRANSIENT_STATUS_CODES = [502, 503, 504];\n\n/**\n * Configuration for retry behavior.\n */\nexport interface RetryConfig {\n  /** Maximum retry attempts for transient failures (default: 2) */\n  maxRetries: number;\n  /** Base delay between retries in ms — doubles each attempt (default: 200) */\n  retryDelayMs: number;\n  /** Maximum retry attempts specifically for 429 rate limiting (default: 4) */\n  maxRateLimitRetries: number;\n}\n\n/**\n * Result of a retry decision: whether to retry, and how long to wait.\n */\nexport interface RetryDecision {\n  /** Whether the request should be retried */\n  shouldRetry: boolean;\n  /** Delay in milliseconds before retrying (with jitter applied) */\n  delayMs: number;\n  /** Human-readable reason for the retry decision */\n  reason: string;\n}\n\n/**\n * Parse a `Retry-After` header value into milliseconds.\n * Supports numeric seconds (e.g. \"5\") and HTTP-date format.\n * Returns `undefined` for missing or invalid values.\n */\nexport function parseRetryAfter(header: string | string[] | undefined): number | undefined {\n  if (!header) return undefined;\n  const value = Array.isArray(header) ? header[0] : header;\n  if (!value) return undefined;\n\n  // Try numeric seconds first\n  const seconds = Number(value);\n  if (!isNaN(seconds) && seconds >= 0) {\n    return Math.min(seconds * 1000, MAX_RETRY_AFTER_MS);\n  }\n\n  // Try HTTP-date\n  const date = Date.parse(value);\n  if (!isNaN(date)) {\n    const delayMs = date - Date.now();\n    if (delayMs > 0) return Math.min(delayMs, MAX_RETRY_AFTER_MS);\n  }\n\n  return undefined;\n}\n\n/**\n * Apply +/-25% random jitter to a delay to prevent thundering herd.\n */\nexport function addJitter(delay: number): number {\n  const jitter = delay * 0.25 * (2 * Math.random() - 1); // -25% to +25%\n  return Math.max(0, Math.round(delay + jitter));\n}\n\n/**\n * Calculate exponential backoff delay for a given attempt.\n *\n * @param baseDelay - Base delay in milliseconds\n * @param attempt - Zero-based attempt number\n * @returns Delay in milliseconds (without jitter)\n */\nexport function calculateBackoff(baseDelay: number, attempt: number): number {\n  return baseDelay * Math.pow(2, attempt);\n}\n\n/**\n * Determine whether a status code represents a transient server error\n * that is eligible for retry (502, 503, 504).\n */\nexport function isTransientStatusCode(statusCode: number): boolean {\n  return TRANSIENT_STATUS_CODES.includes(statusCode);\n}\n\n/**\n * Determine whether a status code indicates rate limiting (429).\n */\nexport function isRateLimited(statusCode: number): boolean {\n  return statusCode === 429;\n}\n\n/**\n * Determine whether a failed response should be retried, and compute the delay.\n *\n * @param statusCode - HTTP status code of the response\n * @param headers - Response headers (used to read Retry-After for 429)\n * @param attempt - Zero-based attempt number\n * @param config - Retry configuration\n * @returns A RetryDecision indicating whether to retry and the delay\n */\nexport function getRetryDecision(\n  statusCode: number,\n  headers: http.IncomingHttpHeaders,\n  attempt: number,\n  config: RetryConfig,\n): RetryDecision {\n  // 429 rate limiting — use Retry-After or longer backoff (4x base)\n  if (isRateLimited(statusCode) && attempt < config.maxRateLimitRetries) {\n    const retryAfter = parseRetryAfter(headers['retry-after']);\n    const rawDelay = retryAfter ?? (config.retryDelayMs * 4 * Math.pow(2, attempt));\n    return {\n      shouldRetry: true,\n      delayMs: addJitter(rawDelay),\n      reason: 'Rate limited (429)',\n    };\n  }\n\n  // 5xx transient server errors — standard exponential backoff\n  if (isTransientStatusCode(statusCode) && attempt < config.maxRetries) {\n    const rawDelay = calculateBackoff(config.retryDelayMs, attempt);\n    return {\n      shouldRetry: true,\n      delayMs: addJitter(rawDelay),\n      reason: `Transient server error (${statusCode})`,\n    };\n  }\n\n  return { shouldRetry: false, delayMs: 0, reason: 'Not retryable' };\n}\n\n/**\n * Determine whether a connection/timeout error should be retried, and compute the delay.\n *\n * @param attempt - Zero-based attempt number\n * @param config - Retry configuration\n * @returns A RetryDecision indicating whether to retry and the delay\n */\nexport function getErrorRetryDecision(\n  attempt: number,\n  config: RetryConfig,\n): RetryDecision {\n  if (attempt < config.maxRetries) {\n    const rawDelay = calculateBackoff(config.retryDelayMs, attempt);\n    return {\n      shouldRetry: true,\n      delayMs: addJitter(rawDelay),\n      reason: 'Connection or timeout error',\n    };\n  }\n\n  return { shouldRetry: false, delayMs: 0, reason: 'Max retries exceeded' };\n}\n"]}

package/lib/types/billing.d.ts

@@ -0,0 +1,47 @@
+import type { QuotaTier } from './quota-tiers';
+/** Billing interval for subscriptions. */
+export type BillingInterval = 'monthly' | 'annual';
+/** Subscription lifecycle status. */
+export type SubscriptionStatus = 'active' | 'canceled' | 'past_due' | 'trialing' | 'incomplete';
+/** Payment transaction status. */
+export type PaymentStatus = 'succeeded' | 'pending' | 'failed' | 'refunded';
+/** Billing event types for audit logging. */
+export type BillingEventType = 'subscription_created' | 'subscription_updated' | 'subscription_canceled' | 'subscription_reactivated' | 'plan_changed' | 'interval_changed' | 'payment_succeeded' | 'payment_failed';
+/** Price definition for a plan (in cents). */
+export interface PlanPrices {
+    monthly: number;
+    annual: number;
+}
+/** Plan definition returned by the billing API. */
+export interface PlanDefinition {
+    id: string;
+    name: string;
+    description: string;
+    tier: QuotaTier;
+    prices: PlanPrices;
+    features: string[];
+    isDefault: boolean;
+    sortOrder: number;
+}
+/** Subscription info returned by the billing API. */
+export interface SubscriptionInfo {
+    id: string;
+    orgId: string;
+    planId: string;
+    status: SubscriptionStatus;
+    interval: BillingInterval;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Billing event info returned by the admin API. */
+export interface BillingEventInfo {
+    id: string;
+    orgId: string;
+    subscriptionId?: string;
+    type: BillingEventType;
+    details: Record<string, unknown>;
+    createdAt: string;
+}

package/lib/types/billing.js

@@ -0,0 +1,5 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/common.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Quota type identifiers.
+ */
+export type QuotaType = 'plugins' | 'pipelines' | 'apiCalls';
+/**
+ * Valid quota type values.
+ */
+export declare const VALID_QUOTA_TYPES: readonly ["plugins", "pipelines", "apiCalls"];
+/**
+ * Type guard to check if a value is a valid QuotaType.
+ *
+ * @param value - Value to check
+ * @returns True if value is a valid QuotaType
+ *
+ * @example
+ * ```typescript
+ * if (isValidQuotaType(req.body.quotaType)) {
+ *   // quotaType is guaranteed to be QuotaType
+ * }
+ * ```
+ */
+export declare function isValidQuotaType(value: unknown): value is QuotaType;
+/**
+ * Validate and assert that a value is a valid QuotaType.
+ * Throws an error if validation fails.
+ *
+ * @param value - Value to validate
+ * @param fieldName - Name of the field being validated (for error messages)
+ * @returns The validated QuotaType
+ * @throws Error if value is not a valid QuotaType
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const quotaType = validateQuotaType(req.body.quotaType, 'quotaType');
+ *   // Use quotaType safely
+ * } catch (err) {
+ *   return sendError(res, 400, err.message);
+ * }
+ * ```
+ */
+export declare function validateQuotaType(value: unknown, fieldName?: string): QuotaType;
+/**
+ * Result from quota check operation.
+ */
+export interface QuotaCheckResult {
+    /** Whether the request is allowed */
+    allowed: boolean;
+    /** Maximum quota limit (-1 for unlimited) */
+    limit: number;
+    /** Current usage count */
+    used: number;
+    /** Remaining quota (-1 for unlimited) */
+    remaining: number;
+    /** ISO timestamp when quota resets */
+    resetAt: string;
+    /** Whether quota is unlimited */
+    unlimited: boolean;
+}
+/**
+ * Quota information for error responses.
+ */
+export interface QuotaInfo {
+    type: QuotaType;
+    limit: number;
+    used: number;
+    remaining: number;
+}
+/**
+ * Standard API success response.
+ */
+export interface ApiSuccessResponse<T = unknown> {
+    success: true;
+    statusCode: number;
+    data?: T;
+    message?: string;
+}
+/**
+ * Standard API error response.
+ */
+export interface ApiErrorResponse {
+    success: false;
+    statusCode: number;
+    message: string;
+    code?: string;
+    details?: unknown;
+    quota?: QuotaInfo;
+}
+/**
+ * Combined API response type.
+ */
+export type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;
+/**
+ * JWT payload from access tokens.
+ *
+ * Users can belong to multiple organizations. The token is scoped to one
+ * active organization at a time. The `role` field is the user's per-org
+ * role in that organization (from the UserOrganization junction collection),
+ * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.
+ *
+ * Use `POST /auth/switch-org` to change the active organization, which
+ * re-issues tokens with the new org's role and context.
+ */
+export interface JwtPayload {
+    /** User ID (subject) */
+    sub: string;
+    /** Username */
+    username: string;
+    /** User email */
+    email: string;
+    /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */
+    role: 'owner' | 'admin' | 'member';
+    /** Derived: true when role is 'admin' or 'owner' in the active organization */
+    isAdmin?: boolean;
+    /** Organization's quota tier ('developer' | 'pro' | 'unlimited') */
+    tier?: string;
+    /** Resolved feature flags for this user/org */
+    features?: string[];
+    /** Active organization ID (from UserOrganization membership) */
+    organizationId?: string;
+    /** Active organization name */
+    organizationName?: string;
+    /** Token type */
+    type: 'access' | 'refresh';
+    /** Issued at timestamp */
+    iat?: number;
+    /** Expiration timestamp */
+    exp?: number;
+}
+/**
+ * Extended Express Request with user property.
+ */
+declare global {
+    namespace Express {
+        interface Request {
+            user?: JwtPayload;
+        }
+    }
+}
+/**
+ * Service configuration for internal HTTP client.
+ */
+export interface ServiceConfig {
+    /** Service hostname */
+    host: string;
+    /** Service port */
+    port: number;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Health check response.
+ */
+export interface HealthCheckResponse {
+    status: 'healthy' | 'unhealthy';
+    service: string;
+    timestamp: string;
+    uptime: number;
+    version?: string;
+    dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;
+}