@pipeline-builder/api-core 0.0.1

package/lib/utils/params.js

@@ -0,0 +1,206 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { getHeaderString } from './headers.js';
+/**
+ * Extract a single string parameter from Express 5 route params.
+ *
+ * @param params - Request params object
+ * @param key - Parameter key
+ * @returns The parameter value as a string, or undefined if not present
+ *
+ * @example
+ * ```typescript
+ * // Route: GET /plugins/:id
+ * const id = getParam(req.params, 'id');
+ * if (!id) {
+ *   return sendError(res, 400, 'Missing id parameter');
+ * }
+ * ```
+ */
+export function getParam(params, key) {
+    const value = params[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    return Array.isArray(value) ? value[0] : value;
+}
+/**
+ * Extract the organization ID from request.
+ * Checks params, headers, and user object.
+ *
+ * @param req - Express request object
+ * @returns Organization ID or undefined
+ *
+ * @example
+ * ```typescript
+ * const orgId = getOrgId(req);
+ * if (!orgId) {
+ *   return sendError(res, 400, 'Organization ID required');
+ * }
+ * ```
+ */
+export function getOrgId(req) {
+    // Prefer the VERIFIED JWT identity first. A spoofable `x-org-id` header must
+    // never override an authenticated user's org (cross-tenant footgun). For a
+    // superadmin acting cross-org, requireAuth already re-points
+    // `req.user.organizationId` to the chosen org via the isSuperAdmin-gated
+    // header override, so this still yields the intended scope.
+    const userOrgId = req.user?.organizationId?.trim();
+    if (userOrgId) {
+        return userOrgId;
+    }
+    // Pre-auth fallbacks only (req.user unset): route param, then header.
+    const paramOrgId = getParam(req.params, 'orgId');
+    if (paramOrgId) {
+        return paramOrgId;
+    }
+    const headerOrgId = getHeaderString(req.headers['x-org-id'])?.trim();
+    if (headerOrgId) {
+        return headerOrgId;
+    }
+    return undefined;
+}
+/**
+ * Parse a query parameter as an integer.
+ *
+ * @param value - Query parameter value
+ * @param defaultValue - Default value if parsing fails
+ * @returns Parsed integer
+ *
+ * @example
+ * ```typescript
+ * const limit = parseQueryInt(req.query.limit, 10);
+ * const offset = parseQueryInt(req.query.offset, 0);
+ * ```
+ */
+export function parseQueryInt(value, defaultValue) {
+    if (value === undefined || value === null || value === '')
+        return defaultValue;
+    const parsed = parseInt(String(value), 10);
+    return isNaN(parsed) ? defaultValue : parsed;
+}
+/**
+ * Parse a query parameter as a string.
+ *
+ * @param value - Query parameter value
+ * @returns String value or undefined
+ *
+ * @example
+ * ```typescript
+ * const search = parseQueryString(req.query.search);
+ * ```
+ */
+export function parseQueryString(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    return String(value);
+}
+/**
+ * Parse a string to a positive integer, returning a fallback if invalid.
+ * Useful for parsing environment variables with numeric defaults.
+ */
+export function parsePositiveInt(value, fallback) {
+    if (!value)
+        return fallback;
+    const parsed = parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+/**
+ * Parse a query int, then clamp to `[1, max]`. Returns `defaultValue` (after
+ * the same clamp) when the input is missing/invalid. Use for `limit`-style
+ * query parameters where an unbounded value would cost real money.
+ *
+ * @example
+ * const limit = parseQueryIntClamped(req.query.limit, 50, 1000);
+ */
+export function parseQueryIntClamped(value, defaultValue, max) {
+    const raw = parseQueryInt(value, defaultValue);
+    return Math.max(1, Math.min(raw, max));
+}
+/**
+ * Bulk-array request guard. Validates that `value` is an array, non-empty,
+ * and within the configured cap. Returns the typed array or an error object
+ * the caller can forward to `sendError`/`sendBadRequest`.
+ *
+ * Replaces a hand-rolled `if (!Array.isArray(...)) { ... }` + length check
+ * block that was duplicated across bulk endpoints in pipeline, plugin,
+ * compliance, etc.
+ *
+ * @example
+ * const result = validateBulkArray(req.body.ids, 'ids');
+ * if ('error' in result) return sendBadRequest(res, result.error, ErrorCode.VALIDATION_ERROR);
+ * const ids = result.value;
+ */
+export function validateBulkArray(value, fieldName, maxItems) {
+    if (!Array.isArray(value) || value.length === 0) {
+        return { error: `Request body must include a non-empty "${fieldName}" array` };
+    }
+    // CoreConstants.MAX_BULK_ITEMS isn't imported here to avoid a circular
+    // path through constants/index; callers pass it explicitly or omit for
+    // no upper bound.
+    if (maxItems !== undefined && value.length > maxItems) {
+        return { error: `Maximum ${maxItems} items per bulk operation` };
+    }
+    return { value: value };
+}
+/**
+ * Supported intervals for time-bucketed report queries. Used as the
+ * `DATE_TRUNC` first argument in Postgres; restricted to a fixed enum so
+ * the value can never be injected into raw SQL.
+ */
+export const REPORT_INTERVALS = ['day', 'week', 'month'];
+/**
+ * Parse + validate a `?interval=` report bucket (defaults to 'week'). Returns the
+ * validated interval or `{ error }`. Shared by the timeseries report routes so the
+ * default + allow-list + error message live in one place.
+ *
+ * @example
+ * const interval = parseReportInterval(req.query);
+ * if (typeof interval === 'object') return sendBadRequest(res, interval.error, ErrorCode.VALIDATION_ERROR);
+ */
+export function parseReportInterval(query) {
+    const interval = String(query.interval ?? 'week');
+    if (!REPORT_INTERVALS.includes(interval)) {
+        return { error: `interval must be one of: ${REPORT_INTERVALS.join(', ')}` };
+    }
+    return interval;
+}
+/**
+ * Parse a `?from=&to=` date range with defaults of "30 days ago → now".
+ * Rejects non-string inputs (Express's parser can produce string[] for
+ * repeated keys), invalid ISO timestamps, and inverted ranges.
+ *
+ * Returns either `{ from, to }` ISO strings or `{ error }`.
+ *
+ * @example
+ * const range = parseDateRange(req.query);
+ * if ('error' in range) return sendBadRequest(res, range.error, ErrorCode.VALIDATION_ERROR);
+ * const rows = await svc.list(range.from, range.to);
+ */
+export function parseDateRange(query, options = {}) {
+    const { maxRangeMs, defaultDaysBack = 30 } = options;
+    const rawFrom = query.from;
+    const rawTo = query.to;
+    if (rawFrom !== undefined && typeof rawFrom !== 'string') {
+        return { error: '"from" must be a single ISO timestamp string' };
+    }
+    if (rawTo !== undefined && typeof rawTo !== 'string') {
+        return { error: '"to" must be a single ISO timestamp string' };
+    }
+    const now = Date.now();
+    const fromStr = rawFrom ?? new Date(now - defaultDaysBack * 24 * 60 * 60 * 1000).toISOString();
+    const toStr = rawTo ?? new Date(now).toISOString();
+    const fromMs = Date.parse(fromStr);
+    const toMs = Date.parse(toStr);
+    if (!Number.isFinite(fromMs))
+        return { error: '"from" is not a valid ISO timestamp' };
+    if (!Number.isFinite(toMs))
+        return { error: '"to" is not a valid ISO timestamp' };
+    if (fromMs > toMs)
+        return { error: '"from" must be earlier than "to"' };
+    if (maxRangeMs !== undefined && toMs - fromMs > maxRangeMs) {
+        return { error: `Date range exceeds maximum of ${Math.floor(maxRangeMs / (24 * 60 * 60 * 1000))} days` };
+    }
+    return { from: fromStr, to: toStr };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"params.js","sourceRoot":"","sources":["../../src/utils/params.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request } from 'express';\nimport { getHeaderString } from './headers.js';\n\n/**\n * Shape convention for the inline parse-guard helpers below.\n *\n * These return a lightweight `{ value } | { error }` (narrowed with\n * `'error' in result`) — deliberately DISTINCT from the schema-validation\n * `ValidationResult<T>` (`{ ok, value } | { ok, error }`) in\n * `validation/middleware.ts`. Zod schema parsing uses the `ok`-discriminated\n * shape; these ad-hoc request-parameter guards use `'error' in`. The split is\n * intentional and documented (see the note on `ValidationResult`): converging\n * them would churn every `'error' in result` call site across the downstream\n * services with no behavioural change, so it's left as a documented convention.\n */\n\n/**\n * Express 5 parameter type.\n */\ntype ParamValue = string | string[] | undefined;\n\n/**\n * Extract a single string parameter from Express 5 route params.\n *\n * @param params - Request params object\n * @param key - Parameter key\n * @returns The parameter value as a string, or undefined if not present\n *\n * @example\n * ```typescript\n * // Route: GET /plugins/:id\n * const id = getParam(req.params, 'id');\n * if (!id) {\n *   return sendError(res, 400, 'Missing id parameter');\n * }\n * ```\n */\nexport function getParam(\n  params: Record<string, ParamValue>,\n  key: string,\n): string | undefined {\n  const value = params[key];\n  if (value === undefined) {\n    return undefined;\n  }\n  return Array.isArray(value) ? value[0] : value;\n}\n\n/**\n * Extract the organization ID from request.\n * Checks params, headers, and user object.\n *\n * @param req - Express request object\n * @returns Organization ID or undefined\n *\n * @example\n * ```typescript\n * const orgId = getOrgId(req);\n * if (!orgId) {\n *   return sendError(res, 400, 'Organization ID required');\n * }\n * ```\n */\nexport function getOrgId(req: Request): string | undefined {\n  // Prefer the VERIFIED JWT identity first. A spoofable `x-org-id` header must\n  // never override an authenticated user's org (cross-tenant footgun). For a\n  // superadmin acting cross-org, requireAuth already re-points\n  // `req.user.organizationId` to the chosen org via the isSuperAdmin-gated\n  // header override, so this still yields the intended scope.\n  const userOrgId = req.user?.organizationId?.trim();\n  if (userOrgId) {\n    return userOrgId;\n  }\n\n  // Pre-auth fallbacks only (req.user unset): route param, then header.\n  const paramOrgId = getParam(req.params, 'orgId');\n  if (paramOrgId) {\n    return paramOrgId;\n  }\n\n  const headerOrgId = getHeaderString(req.headers['x-org-id'])?.trim();\n  if (headerOrgId) {\n    return headerOrgId;\n  }\n\n  return undefined;\n}\n\n/**\n * Parse a query parameter as an integer.\n *\n * @param value - Query parameter value\n * @param defaultValue - Default value if parsing fails\n * @returns Parsed integer\n *\n * @example\n * ```typescript\n * const limit = parseQueryInt(req.query.limit, 10);\n * const offset = parseQueryInt(req.query.offset, 0);\n * ```\n */\nexport function parseQueryInt(value: unknown, defaultValue: number): number {\n  if (value === undefined || value === null || value === '') return defaultValue;\n  const parsed = parseInt(String(value), 10);\n  return isNaN(parsed) ? defaultValue : parsed;\n}\n\n/**\n * Parse a query parameter as a string.\n *\n * @param value - Query parameter value\n * @returns String value or undefined\n *\n * @example\n * ```typescript\n * const search = parseQueryString(req.query.search);\n * ```\n */\nexport function parseQueryString(value: unknown): string | undefined {\n  if (value === undefined || value === null || value === '') return undefined;\n  return String(value);\n}\n\n/**\n * Parse a string to a positive integer, returning a fallback if invalid.\n * Useful for parsing environment variables with numeric defaults.\n */\nexport function parsePositiveInt(value: string | undefined, fallback: number): number {\n  if (!value) return fallback;\n  const parsed = parseInt(value, 10);\n  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;\n}\n\n/**\n * Parse a query int, then clamp to `[1, max]`. Returns `defaultValue` (after\n * the same clamp) when the input is missing/invalid. Use for `limit`-style\n * query parameters where an unbounded value would cost real money.\n *\n * @example\n * const limit = parseQueryIntClamped(req.query.limit, 50, 1000);\n */\nexport function parseQueryIntClamped(\n  value: unknown,\n  defaultValue: number,\n  max: number,\n): number {\n  const raw = parseQueryInt(value, defaultValue);\n  return Math.max(1, Math.min(raw, max));\n}\n\n/**\n * Bulk-array request guard. Validates that `value` is an array, non-empty,\n * and within the configured cap. Returns the typed array or an error object\n * the caller can forward to `sendError`/`sendBadRequest`.\n *\n * Replaces a hand-rolled `if (!Array.isArray(...)) { ... }` + length check\n * block that was duplicated across bulk endpoints in pipeline, plugin,\n * compliance, etc.\n *\n * @example\n * const result = validateBulkArray(req.body.ids, 'ids');\n * if ('error' in result) return sendBadRequest(res, result.error, ErrorCode.VALIDATION_ERROR);\n * const ids = result.value;\n */\nexport function validateBulkArray<T = unknown>(\n  value: unknown,\n  fieldName: string,\n  maxItems?: number,\n): { value: T[] } | { error: string } {\n  if (!Array.isArray(value) || value.length === 0) {\n    return { error: `Request body must include a non-empty \"${fieldName}\" array` };\n  }\n  // CoreConstants.MAX_BULK_ITEMS isn't imported here to avoid a circular\n  // path through constants/index; callers pass it explicitly or omit for\n  // no upper bound.\n  if (maxItems !== undefined && value.length > maxItems) {\n    return { error: `Maximum ${maxItems} items per bulk operation` };\n  }\n  return { value: value as T[] };\n}\n\n/**\n * Supported intervals for time-bucketed report queries. Used as the\n * `DATE_TRUNC` first argument in Postgres; restricted to a fixed enum so\n * the value can never be injected into raw SQL.\n */\nexport const REPORT_INTERVALS = ['day', 'week', 'month'] as const;\nexport type ReportInterval = (typeof REPORT_INTERVALS)[number];\n\n/**\n * Parse + validate a `?interval=` report bucket (defaults to 'week'). Returns the\n * validated interval or `{ error }`. Shared by the timeseries report routes so the\n * default + allow-list + error message live in one place.\n *\n * @example\n * const interval = parseReportInterval(req.query);\n * if (typeof interval === 'object') return sendBadRequest(res, interval.error, ErrorCode.VALIDATION_ERROR);\n */\nexport function parseReportInterval(query: Record<string, unknown>): ReportInterval | { error: string } {\n  const interval = String(query.interval ?? 'week');\n  if (!REPORT_INTERVALS.includes(interval as ReportInterval)) {\n    return { error: `interval must be one of: ${REPORT_INTERVALS.join(', ')}` };\n  }\n  return interval as ReportInterval;\n}\n\n/**\n * Parse a `?from=&to=` date range with defaults of \"30 days ago → now\".\n * Rejects non-string inputs (Express's parser can produce string[] for\n * repeated keys), invalid ISO timestamps, and inverted ranges.\n *\n * Returns either `{ from, to }` ISO strings or `{ error }`.\n *\n * @example\n * const range = parseDateRange(req.query);\n * if ('error' in range) return sendBadRequest(res, range.error, ErrorCode.VALIDATION_ERROR);\n * const rows = await svc.list(range.from, range.to);\n */\nexport function parseDateRange(\n  query: Record<string, unknown>,\n  options: { maxRangeMs?: number; defaultDaysBack?: number } = {},\n): { from: string; to: string } | { error: string } {\n  const { maxRangeMs, defaultDaysBack = 30 } = options;\n\n  const rawFrom = query.from;\n  const rawTo = query.to;\n\n  if (rawFrom !== undefined && typeof rawFrom !== 'string') {\n    return { error: '\"from\" must be a single ISO timestamp string' };\n  }\n  if (rawTo !== undefined && typeof rawTo !== 'string') {\n    return { error: '\"to\" must be a single ISO timestamp string' };\n  }\n\n  const now = Date.now();\n  const fromStr = rawFrom ?? new Date(now - defaultDaysBack * 24 * 60 * 60 * 1000).toISOString();\n  const toStr = rawTo ?? new Date(now).toISOString();\n\n  const fromMs = Date.parse(fromStr);\n  const toMs = Date.parse(toStr);\n  if (!Number.isFinite(fromMs)) return { error: '\"from\" is not a valid ISO timestamp' };\n  if (!Number.isFinite(toMs)) return { error: '\"to\" is not a valid ISO timestamp' };\n  if (fromMs > toMs) return { error: '\"from\" must be earlier than \"to\"' };\n  if (maxRangeMs !== undefined && toMs - fromMs > maxRangeMs) {\n    return { error: `Date range exceeds maximum of ${Math.floor(maxRangeMs / (24 * 60 * 60 * 1000))} days` };\n  }\n\n  return { from: fromStr, to: toStr };\n}\n"]}

package/lib/utils/response.d.ts

@@ -0,0 +1,117 @@
+import type { Response } from 'express';
+import type { QuotaInfo } from '../types/common.js';
+import { ErrorCode } from '../types/error-codes.js';
+/**
+ * Send a standardized success response.
+ *
+ * @param res - Express response object
+ * @param statusCode - HTTP status code (default: 200)
+ * @param data - Response data
+ * @param message - Optional success message
+ *
+ * @example
+ * ```typescript
+ * sendSuccess(res, 200, { plugin: pluginData });
+ * sendSuccess(res, 201, { id: newId }, 'Resource created');
+ * ```
+ */
+export declare function sendSuccess<T>(res: Response, statusCode?: number, data?: T, message?: string): void;
+/**
+ * Send a standardized error response.
+ *
+ * @param res - Express response object
+ * @param statusCode - HTTP status code
+ * @param message - Error message
+ * @param code - Error code from ErrorCode enum
+ * @param details - Optional additional details
+ *
+ * @example
+ * ```typescript
+ * sendError(res, 404, 'Plugin not found', ErrorCode.NOT_FOUND);
+ * sendError(res, 400, 'Invalid input', ErrorCode.VALIDATION_ERROR, { field: 'name' });
+ * ```
+ */
+export declare function sendError(res: Response, statusCode: number, message: string, code?: ErrorCode | string, details?: unknown): void;
+/**
+ * Send a quota exceeded error response.
+ *
+ * @param res - Express response object
+ * @param quotaType - Type of quota exceeded
+ * @param quota - Current quota information
+ * @param resetAt - ISO timestamp when quota resets
+ *
+ * @example
+ * ```typescript
+ * sendQuotaExceeded(res, 'apiCalls', { type: 'apiCalls', limit: 10000, used: 10000, remaining: 0 }, resetAt);
+ * ```
+ */
+export declare function sendQuotaExceeded(res: Response, quotaType: string, quota: QuotaInfo, resetAt?: string, message?: string): void;
+/**
+ * Send a paginated list response with the items nested under a named key.
+ * Use when the API contract is `{ <key>: [...], pagination: {...} }`
+ * (the dominant shape across api/* services).
+ *
+ * @example
+ * ```typescript
+ * sendPaginatedNested(res, 'pipelines', items, {
+ *   total: 50, limit: 25, offset: 0, hasMore: true,
+ * });
+ * // → { pipelines: [...], pagination: { total: 50, limit: 25, offset: 0, hasMore: true } }
+ * ```
+ */
+export declare function sendPaginatedNested<T>(res: Response, dataKey: string, data: T[], options: {
+    total?: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+    nextCursor?: string;
+    statusCode?: number;
+}): void;
+/**
+ * Extract database error details for logging/response.
+ *
+ * Extracts PostgreSQL error codes, details, hints, and constraint names
+ * from database errors for better error messages.
+ *
+ * @param error - Error object from database operation
+ * @returns Object with extracted error details
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await db.insert(plugins).values(newPlugin);
+ * } catch (error) {
+ *   const dbDetails = extractDbError(error);
+ *   return sendError(res, 500, 'Database error', ErrorCode.DATABASE_ERROR, dbDetails);
+ * }
+ * ```
+ */
+export declare function extractDbError(error: unknown): Record<string, unknown>;
+/**
+ * Extract a human-readable message from an unknown catch value.
+ *
+ * Falls back beyond `.message` because several common Node errors carry an
+ * EMPTY `.message`:
+ *  - dual-stack (IPv4+IPv6) connect failures surface as an `AggregateError`
+ *    whose own message is blank — the cause lives in `.code` (e.g.
+ *    `ECONNREFUSED`/`ETIMEDOUT`) and/or the `.errors[]` sub-errors;
+ *  - raw socket `ErrnoException`s can likewise carry only a `.code`.
+ * Without this, an unreachable internal service (e.g. compliance still
+ * starting) produced blank per-item errors in bulk responses and `error:""`
+ * in logs — a silent black box. Order: message → code → joined sub-errors →
+ * error name.
+ */
+export declare function errorMessage(error: unknown): string;
+/** Send a 400 bad-request response. */
+export declare function sendBadRequest(res: Response, message: string, code?: ErrorCode | string): void;
+/** Send a 500 internal error response. */
+export declare function sendInternalError(res: Response, message: string, details?: Record<string, unknown>): void;
+/** Common pagination + sorting parameters. */
+export interface PaginationParams {
+    limit: number;
+    offset: number;
+    sortBy: string;
+    sortOrder: 'asc' | 'desc';
+}
+/** Parse pagination/sort params from query string, clamping to safe defaults. */
+export declare function parsePaginationParams(query: Record<string, unknown>): PaginationParams;

package/lib/utils/response.js

@@ -0,0 +1,223 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createLogger } from './logger.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { MAX_PAGE_LIMIT, MAX_PAGE_OFFSET } from '../validation/common-schemas.js';
+const logger = createLogger('response');
+/**
+ * Send a standardized success response.
+ *
+ * @param res - Express response object
+ * @param statusCode - HTTP status code (default: 200)
+ * @param data - Response data
+ * @param message - Optional success message
+ *
+ * @example
+ * ```typescript
+ * sendSuccess(res, 200, { plugin: pluginData });
+ * sendSuccess(res, 201, { id: newId }, 'Resource created');
+ * ```
+ */
+export function sendSuccess(res, statusCode = 200, data, message) {
+    if (res.headersSent) {
+        logger.warn('Attempted to send success after headers already sent', { statusCode });
+        return;
+    }
+    const response = {
+        success: true,
+        statusCode,
+    };
+    if (data !== undefined) {
+        response.data = data;
+    }
+    if (message) {
+        response.message = message;
+    }
+    res.status(statusCode).json(response);
+}
+/**
+ * Send a standardized error response.
+ *
+ * @param res - Express response object
+ * @param statusCode - HTTP status code
+ * @param message - Error message
+ * @param code - Error code from ErrorCode enum
+ * @param details - Optional additional details
+ *
+ * @example
+ * ```typescript
+ * sendError(res, 404, 'Plugin not found', ErrorCode.NOT_FOUND);
+ * sendError(res, 400, 'Invalid input', ErrorCode.VALIDATION_ERROR, { field: 'name' });
+ * ```
+ */
+export function sendError(res, statusCode, message, code, details) {
+    if (res.headersSent) {
+        logger.warn('Attempted to send error after headers already sent', { statusCode, message });
+        return;
+    }
+    const response = {
+        success: false,
+        statusCode,
+        message,
+    };
+    if (code) {
+        response.code = code;
+    }
+    if (details !== undefined) {
+        response.details = details;
+    }
+    res.status(statusCode).json(response);
+}
+/**
+ * Send a quota exceeded error response.
+ *
+ * @param res - Express response object
+ * @param quotaType - Type of quota exceeded
+ * @param quota - Current quota information
+ * @param resetAt - ISO timestamp when quota resets
+ *
+ * @example
+ * ```typescript
+ * sendQuotaExceeded(res, 'apiCalls', { type: 'apiCalls', limit: 10000, used: 10000, remaining: 0 }, resetAt);
+ * ```
+ */
+export function sendQuotaExceeded(res, quotaType, quota, resetAt, message) {
+    const resetDate = resetAt ? new Date(resetAt) : new Date();
+    const resetIn = Math.max(0, Math.ceil((resetDate.getTime() - Date.now()) / 1000));
+    // Guard like the sibling helpers: `setHeader` throws synchronously once the
+    // response has been sent, so skip the quota headers (and let `sendError` no-op)
+    // instead of crashing the handler on an already-committed response.
+    if (!res.headersSent) {
+        res.setHeader('Retry-After', resetIn);
+        res.setHeader('X-Quota-Limit', quota.limit);
+        res.setHeader('X-Quota-Used', quota.used);
+        res.setHeader('X-Quota-Remaining', Math.max(0, quota.remaining));
+        if (resetAt) {
+            res.setHeader('X-Quota-Reset', resetAt);
+        }
+    }
+    sendError(res, 429, message ?? `${quotaType} quota exceeded (${quota.used}/${quota.limit}). Please try again later.`, ErrorCode.QUOTA_EXCEEDED, { quota });
+}
+/**
+ * Send a paginated list response with the items nested under a named key.
+ * Use when the API contract is `{ <key>: [...], pagination: {...} }`
+ * (the dominant shape across api/* services).
+ *
+ * @example
+ * ```typescript
+ * sendPaginatedNested(res, 'pipelines', items, {
+ *   total: 50, limit: 25, offset: 0, hasMore: true,
+ * });
+ * // → { pipelines: [...], pagination: { total: 50, limit: 25, offset: 0, hasMore: true } }
+ * ```
+ */
+export function sendPaginatedNested(res, dataKey, data, options) {
+    if (res.headersSent) {
+        logger.warn('Attempted to send paginated response after headers already sent');
+        return;
+    }
+    const { statusCode = 200, total, limit, offset, hasMore, nextCursor } = options;
+    const pagination = { limit, offset, hasMore };
+    if (total !== undefined)
+        pagination.total = total;
+    if (nextCursor)
+        pagination.nextCursor = nextCursor;
+    res.status(statusCode).json({
+        success: true,
+        statusCode,
+        data: { [dataKey]: data, pagination },
+    });
+}
+/**
+ * Extract database error details for logging/response.
+ *
+ * Extracts PostgreSQL error codes, details, hints, and constraint names
+ * from database errors for better error messages.
+ *
+ * @param error - Error object from database operation
+ * @returns Object with extracted error details
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await db.insert(plugins).values(newPlugin);
+ * } catch (error) {
+ *   const dbDetails = extractDbError(error);
+ *   return sendError(res, 500, 'Database error', ErrorCode.DATABASE_ERROR, dbDetails);
+ * }
+ * ```
+ */
+export function extractDbError(error) {
+    if (!error || typeof error !== 'object') {
+        return {};
+    }
+    // Drizzle ORM wraps the original pg error in error.cause —
+    // check the cause first, then fall back to the error itself.
+    const err = error;
+    const source = (err.cause && typeof err.cause === 'object' ? err.cause : err);
+    const details = {};
+    if (source.code)
+        details.dbCode = source.code;
+    if (source.detail)
+        details.dbDetail = source.detail;
+    if (source.hint)
+        details.dbHint = source.hint;
+    if (source.constraint)
+        details.constraint = source.constraint;
+    if (source.table)
+        details.table = source.table;
+    if (source.column)
+        details.column = source.column;
+    return details;
+}
+// Convenience helpers (shared across plugin, pipeline, quota services)
+/**
+ * Extract a human-readable message from an unknown catch value.
+ *
+ * Falls back beyond `.message` because several common Node errors carry an
+ * EMPTY `.message`:
+ *  - dual-stack (IPv4+IPv6) connect failures surface as an `AggregateError`
+ *    whose own message is blank — the cause lives in `.code` (e.g.
+ *    `ECONNREFUSED`/`ETIMEDOUT`) and/or the `.errors[]` sub-errors;
+ *  - raw socket `ErrnoException`s can likewise carry only a `.code`.
+ * Without this, an unreachable internal service (e.g. compliance still
+ * starting) produced blank per-item errors in bulk responses and `error:""`
+ * in logs — a silent black box. Order: message → code → joined sub-errors →
+ * error name.
+ */
+export function errorMessage(error) {
+    if (!(error instanceof Error))
+        return String(error);
+    if (error.message)
+        return error.message;
+    const code = error.code;
+    if (code)
+        return code;
+    const inner = error.errors;
+    if (Array.isArray(inner) && inner.length > 0) {
+        const joined = inner.map(errorMessage).filter(Boolean).join('; ');
+        if (joined)
+            return joined;
+    }
+    return error.name || 'Unknown error';
+}
+/** Send a 400 bad-request response. */
+export function sendBadRequest(res, message, code = ErrorCode.VALIDATION_ERROR) {
+    sendError(res, 400, message, code);
+}
+/** Send a 500 internal error response. */
+export function sendInternalError(res, message, details) {
+    sendError(res, 500, message, ErrorCode.INTERNAL_ERROR, details);
+}
+/** Parse pagination/sort params from query string, clamping to safe defaults. */
+export function parsePaginationParams(query) {
+    const limit = Math.min(Math.max(parseInt(String(query.limit), 10) || 10, 1), MAX_PAGE_LIMIT);
+    // Clamp offset too — an unbounded offset forces Postgres to scan+discard huge row
+    // counts on hot list endpoints (a cheap DoS amplifier). Deep paging should use the
+    // cursor API. Ceiling = MAX_PAGE_OFFSET.
+    const offset = Math.min(Math.max(parseInt(String(query.offset), 10) || 0, 0), MAX_PAGE_OFFSET);
+    const sortBy = String(query.sortBy || 'createdAt');
+    const sortOrder = String(query.sortOrder || 'desc').toLowerCase() === 'asc' ? 'asc' : 'desc';
+    return { limit, offset, sortBy, sortOrder };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/utils/response.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Response } from 'express';\nimport { createLogger } from './logger.js';\nimport type { QuotaInfo } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { MAX_PAGE_LIMIT, MAX_PAGE_OFFSET } from '../validation/common-schemas.js';\n\nconst logger = createLogger('response');\n\n/**\n * Send a standardized success response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code (default: 200)\n * @param data - Response data\n * @param message - Optional success message\n *\n * @example\n * ```typescript\n * sendSuccess(res, 200, { plugin: pluginData });\n * sendSuccess(res, 201, { id: newId }, 'Resource created');\n * ```\n */\nexport function sendSuccess<T>(\n  res: Response,\n  statusCode: number = 200,\n  data?: T,\n  message?: string,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send success after headers already sent', { statusCode });\n    return;\n  }\n\n  const response: {\n    success: true;\n    statusCode: number;\n    data?: T;\n    message?: string;\n  } = {\n    success: true,\n    statusCode,\n  };\n\n  if (data !== undefined) {\n    response.data = data;\n  }\n\n  if (message) {\n    response.message = message;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a standardized error response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code\n * @param message - Error message\n * @param code - Error code from ErrorCode enum\n * @param details - Optional additional details\n *\n * @example\n * ```typescript\n * sendError(res, 404, 'Plugin not found', ErrorCode.NOT_FOUND);\n * sendError(res, 400, 'Invalid input', ErrorCode.VALIDATION_ERROR, { field: 'name' });\n * ```\n */\nexport function sendError(\n  res: Response,\n  statusCode: number,\n  message: string,\n  code?: ErrorCode | string,\n  details?: unknown,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send error after headers already sent', { statusCode, message });\n    return;\n  }\n\n  const response: {\n    success: false;\n    statusCode: number;\n    message: string;\n    code?: string;\n    details?: unknown;\n  } = {\n    success: false,\n    statusCode,\n    message,\n  };\n\n  if (code) {\n    response.code = code;\n  }\n\n  if (details !== undefined) {\n    response.details = details;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a quota exceeded error response.\n *\n * @param res - Express response object\n * @param quotaType - Type of quota exceeded\n * @param quota - Current quota information\n * @param resetAt - ISO timestamp when quota resets\n *\n * @example\n * ```typescript\n * sendQuotaExceeded(res, 'apiCalls', { type: 'apiCalls', limit: 10000, used: 10000, remaining: 0 }, resetAt);\n * ```\n */\nexport function sendQuotaExceeded(\n  res: Response,\n  quotaType: string,\n  quota: QuotaInfo,\n  resetAt?: string,\n  message?: string,\n): void {\n  const resetDate = resetAt ? new Date(resetAt) : new Date();\n  const resetIn = Math.max(0, Math.ceil((resetDate.getTime() - Date.now()) / 1000));\n\n  // Guard like the sibling helpers: `setHeader` throws synchronously once the\n  // response has been sent, so skip the quota headers (and let `sendError` no-op)\n  // instead of crashing the handler on an already-committed response.\n  if (!res.headersSent) {\n    res.setHeader('Retry-After', resetIn);\n    res.setHeader('X-Quota-Limit', quota.limit);\n    res.setHeader('X-Quota-Used', quota.used);\n    res.setHeader('X-Quota-Remaining', Math.max(0, quota.remaining));\n\n    if (resetAt) {\n      res.setHeader('X-Quota-Reset', resetAt);\n    }\n  }\n\n  sendError(\n    res,\n    429,\n    message ?? `${quotaType} quota exceeded (${quota.used}/${quota.limit}). Please try again later.`,\n    ErrorCode.QUOTA_EXCEEDED,\n    { quota },\n  );\n}\n\n/**\n * Send a paginated list response with the items nested under a named key.\n * Use when the API contract is `{ <key>: [...], pagination: {...} }`\n * (the dominant shape across api/* services).\n *\n * @example\n * ```typescript\n * sendPaginatedNested(res, 'pipelines', items, {\n *   total: 50, limit: 25, offset: 0, hasMore: true,\n * });\n * // → { pipelines: [...], pagination: { total: 50, limit: 25, offset: 0, hasMore: true } }\n * ```\n */\nexport function sendPaginatedNested<T>(\n  res: Response,\n  dataKey: string,\n  data: T[],\n  options: {\n    total?: number;\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n    nextCursor?: string;\n    statusCode?: number;\n  },\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send paginated response after headers already sent');\n    return;\n  }\n  const { statusCode = 200, total, limit, offset, hasMore, nextCursor } = options;\n  const pagination: Record<string, unknown> = { limit, offset, hasMore };\n  if (total !== undefined) pagination.total = total;\n  if (nextCursor) pagination.nextCursor = nextCursor;\n  res.status(statusCode).json({\n    success: true,\n    statusCode,\n    data: { [dataKey]: data, pagination },\n  });\n}\n\n/**\n * Extract database error details for logging/response.\n *\n * Extracts PostgreSQL error codes, details, hints, and constraint names\n * from database errors for better error messages.\n *\n * @param error - Error object from database operation\n * @returns Object with extracted error details\n *\n * @example\n * ```typescript\n * try {\n *   await db.insert(plugins).values(newPlugin);\n * } catch (error) {\n *   const dbDetails = extractDbError(error);\n *   return sendError(res, 500, 'Database error', ErrorCode.DATABASE_ERROR, dbDetails);\n * }\n * ```\n */\nexport function extractDbError(error: unknown): Record<string, unknown> {\n  if (!error || typeof error !== 'object') {\n    return {};\n  }\n\n  // Drizzle ORM wraps the original pg error in error.cause —\n  // check the cause first, then fall back to the error itself.\n  const err = error as Record<string, unknown>;\n  const source = (err.cause && typeof err.cause === 'object' ? err.cause : err) as Record<string, unknown>;\n  const details: Record<string, unknown> = {};\n\n  if (source.code) details.dbCode = source.code;\n  if (source.detail) details.dbDetail = source.detail;\n  if (source.hint) details.dbHint = source.hint;\n  if (source.constraint) details.constraint = source.constraint;\n  if (source.table) details.table = source.table;\n  if (source.column) details.column = source.column;\n\n  return details;\n}\n\n// Convenience helpers (shared across plugin, pipeline, quota services)\n\n/**\n * Extract a human-readable message from an unknown catch value.\n *\n * Falls back beyond `.message` because several common Node errors carry an\n * EMPTY `.message`:\n *  - dual-stack (IPv4+IPv6) connect failures surface as an `AggregateError`\n *    whose own message is blank — the cause lives in `.code` (e.g.\n *    `ECONNREFUSED`/`ETIMEDOUT`) and/or the `.errors[]` sub-errors;\n *  - raw socket `ErrnoException`s can likewise carry only a `.code`.\n * Without this, an unreachable internal service (e.g. compliance still\n * starting) produced blank per-item errors in bulk responses and `error:\"\"`\n * in logs — a silent black box. Order: message → code → joined sub-errors →\n * error name.\n */\nexport function errorMessage(error: unknown): string {\n  if (!(error instanceof Error)) return String(error);\n  if (error.message) return error.message;\n\n  const code = (error as { code?: string }).code;\n  if (code) return code;\n\n  const inner = (error as { errors?: unknown[] }).errors;\n  if (Array.isArray(inner) && inner.length > 0) {\n    const joined = inner.map(errorMessage).filter(Boolean).join('; ');\n    if (joined) return joined;\n  }\n\n  return error.name || 'Unknown error';\n}\n\n/** Send a 400 bad-request response. */\nexport function sendBadRequest(\n  res: Response,\n  message: string,\n  code: ErrorCode | string = ErrorCode.VALIDATION_ERROR,\n): void {\n  sendError(res, 400, message, code);\n}\n\n/** Send a 500 internal error response. */\nexport function sendInternalError(\n  res: Response,\n  message: string,\n  details?: Record<string, unknown>,\n): void {\n  sendError(res, 500, message, ErrorCode.INTERNAL_ERROR, details);\n}\n\n// Pagination\n\n/** Common pagination + sorting parameters. */\nexport interface PaginationParams {\n  limit: number;\n  offset: number;\n  sortBy: string;\n  sortOrder: 'asc' | 'desc';\n}\n\n/** Parse pagination/sort params from query string, clamping to safe defaults. */\nexport function parsePaginationParams(query: Record<string, unknown>): PaginationParams {\n  const limit = Math.min(Math.max(parseInt(String(query.limit), 10) || 10, 1), MAX_PAGE_LIMIT);\n  // Clamp offset too — an unbounded offset forces Postgres to scan+discard huge row\n  // counts on hot list endpoints (a cheap DoS amplifier). Deep paging should use the\n  // cursor API. Ceiling = MAX_PAGE_OFFSET.\n  const offset = Math.min(Math.max(parseInt(String(query.offset), 10) || 0, 0), MAX_PAGE_OFFSET);\n  const sortBy = String(query.sortBy || 'createdAt');\n  const sortOrder: 'asc' | 'desc' =\n    String(query.sortOrder || 'desc').toLowerCase() === 'asc' ? 'asc' : 'desc';\n\n  return { limit, offset, sortBy, sortOrder };\n}\n"]}

package/lib/utils/safe-require.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Build a CommonJS `require` for synchronously loading OPTIONAL installed
+ * packages from ESM code (e.g. prom-client, @opentelemetry/api, ioredis behind
+ * a try/catch).
+ *
+ * Pass `import.meta.url`. When this ESM source is bundled to CJS — as the CDK
+ * Lambda handlers are — esbuild replaces `import.meta` with `{}`, so the value
+ * is `undefined` and a bare `createRequire(import.meta.url)` throws at module
+ * load ("The argument 'filename' must be a file URL… Received undefined"). We
+ * fall back to the process entry path so there's always a valid resolution base
+ * (the base only needs to exist within the project for node_modules lookup).
+ */
+export declare function safeCreateRequire(metaUrl: string | undefined): NodeRequire;

package/lib/utils/safe-require.js

@@ -0,0 +1,19 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createRequire } from 'node:module';
+/**
+ * Build a CommonJS `require` for synchronously loading OPTIONAL installed
+ * packages from ESM code (e.g. prom-client, @opentelemetry/api, ioredis behind
+ * a try/catch).
+ *
+ * Pass `import.meta.url`. When this ESM source is bundled to CJS — as the CDK
+ * Lambda handlers are — esbuild replaces `import.meta` with `{}`, so the value
+ * is `undefined` and a bare `createRequire(import.meta.url)` throws at module
+ * load ("The argument 'filename' must be a file URL… Received undefined"). We
+ * fall back to the process entry path so there's always a valid resolution base
+ * (the base only needs to exist within the project for node_modules lookup).
+ */
+export function safeCreateRequire(metaUrl) {
+    return createRequire(metaUrl || process.argv[1] || `${process.cwd()}/index.js`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FmZS1yZXF1aXJlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3NhZmUtcmVxdWlyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFNUM7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxNQUFNLFVBQVUsaUJBQWlCLENBQUMsT0FBMkI7SUFDM0QsT0FBTyxhQUFhLENBQUMsT0FBTyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFLFdBQVcsQ0FBQyxDQUFDO0FBQ2xGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuaW1wb3J0IHsgY3JlYXRlUmVxdWlyZSB9IGZyb20gJ25vZGU6bW9kdWxlJztcblxuLyoqXG4gKiBCdWlsZCBhIENvbW1vbkpTIGByZXF1aXJlYCBmb3Igc3luY2hyb25vdXNseSBsb2FkaW5nIE9QVElPTkFMIGluc3RhbGxlZFxuICogcGFja2FnZXMgZnJvbSBFU00gY29kZSAoZS5nLiBwcm9tLWNsaWVudCwgQG9wZW50ZWxlbWV0cnkvYXBpLCBpb3JlZGlzIGJlaGluZFxuICogYSB0cnkvY2F0Y2gpLlxuICpcbiAqIFBhc3MgYGltcG9ydC5tZXRhLnVybGAuIFdoZW4gdGhpcyBFU00gc291cmNlIGlzIGJ1bmRsZWQgdG8gQ0pTIOKAlCBhcyB0aGUgQ0RLXG4gKiBMYW1iZGEgaGFuZGxlcnMgYXJlIOKAlCBlc2J1aWxkIHJlcGxhY2VzIGBpbXBvcnQubWV0YWAgd2l0aCBge31gLCBzbyB0aGUgdmFsdWVcbiAqIGlzIGB1bmRlZmluZWRgIGFuZCBhIGJhcmUgYGNyZWF0ZVJlcXVpcmUoaW1wb3J0Lm1ldGEudXJsKWAgdGhyb3dzIGF0IG1vZHVsZVxuICogbG9hZCAoXCJUaGUgYXJndW1lbnQgJ2ZpbGVuYW1lJyBtdXN0IGJlIGEgZmlsZSBVUkzigKYgUmVjZWl2ZWQgdW5kZWZpbmVkXCIpLiBXZVxuICogZmFsbCBiYWNrIHRvIHRoZSBwcm9jZXNzIGVudHJ5IHBhdGggc28gdGhlcmUncyBhbHdheXMgYSB2YWxpZCByZXNvbHV0aW9uIGJhc2VcbiAqICh0aGUgYmFzZSBvbmx5IG5lZWRzIHRvIGV4aXN0IHdpdGhpbiB0aGUgcHJvamVjdCBmb3Igbm9kZV9tb2R1bGVzIGxvb2t1cCkuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzYWZlQ3JlYXRlUmVxdWlyZShtZXRhVXJsOiBzdHJpbmcgfCB1bmRlZmluZWQpOiBOb2RlUmVxdWlyZSB7XG4gIHJldHVybiBjcmVhdGVSZXF1aXJlKG1ldGFVcmwgfHwgcHJvY2Vzcy5hcmd2WzFdIHx8IGAke3Byb2Nlc3MuY3dkKCl9L2luZGV4LmpzYCk7XG59XG4iXX0=