@pipeline-builder/api-core 3.1.0

package/lib/utils/params.js

@@ -0,0 +1,148 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParam = getParam;
+exports.getOrgId = getOrgId;
+exports.getAuthHeader = getAuthHeader;
+exports.parseQueryBoolean = parseQueryBoolean;
+exports.parseQueryInt = parseQueryInt;
+exports.parseQueryString = parseQueryString;
+exports.parsePositiveInt = parsePositiveInt;
+const headers_1 = require("./headers");
+/**
+ * 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');
+ * }
+ * ```
+ */
+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');
+ * }
+ * ```
+ */
+function getOrgId(req) {
+    // Check route params first
+    const paramOrgId = getParam(req.params, 'orgId');
+    if (paramOrgId) {
+        return paramOrgId;
+    }
+    // Check x-org-id header
+    const headerOrgId = (0, headers_1.getHeaderString)(req.headers['x-org-id'])?.trim();
+    if (headerOrgId) {
+        return headerOrgId;
+    }
+    // Check authenticated user
+    const userOrgId = req.user?.organizationId?.trim();
+    if (userOrgId) {
+        return userOrgId;
+    }
+    return undefined;
+}
+/**
+ * Get the authorization header from request.
+ *
+ * @param req - Express request object
+ * @returns Authorization header value or empty string
+ */
+function getAuthHeader(req) {
+    return (0, headers_1.getHeaderString)(req.headers.authorization) ?? '';
+}
+/**
+ * Parse a query parameter as a boolean.
+ *
+ * @param value - Query parameter value
+ * @returns Parsed boolean or undefined
+ *
+ * @example
+ * ```typescript
+ * const isActive = parseQueryBoolean(req.query.isActive);
+ * ```
+ */
+function parseQueryBoolean(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string') {
+        const lower = value.toLowerCase();
+        if (lower === 'true' || lower === '1')
+            return true;
+        if (lower === 'false' || lower === '0')
+            return false;
+    }
+    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);
+ * ```
+ */
+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);
+ * ```
+ */
+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.
+ */
+function parsePositiveInt(value, fallback) {
+    if (!value)
+        return fallback;
+    const parsed = parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+//# 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 { Request } from 'express';\nimport { getHeaderString } from './headers';\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  // Check route params first\n  const paramOrgId = getParam(req.params, 'orgId');\n  if (paramOrgId) {\n    return paramOrgId;\n  }\n\n  // Check x-org-id header\n  const headerOrgId = getHeaderString(req.headers['x-org-id'])?.trim();\n  if (headerOrgId) {\n    return headerOrgId;\n  }\n\n  // Check authenticated user\n  const userOrgId = req.user?.organizationId?.trim();\n  if (userOrgId) {\n    return userOrgId;\n  }\n\n  return undefined;\n}\n\n/**\n * Get the authorization header from request.\n *\n * @param req - Express request object\n * @returns Authorization header value or empty string\n */\nexport function getAuthHeader(req: Request): string {\n  return getHeaderString(req.headers.authorization) ?? '';\n}\n\n/**\n * Parse a query parameter as a boolean.\n *\n * @param value - Query parameter value\n * @returns Parsed boolean or undefined\n *\n * @example\n * ```typescript\n * const isActive = parseQueryBoolean(req.query.isActive);\n * ```\n */\nexport function parseQueryBoolean(value: unknown): boolean | undefined {\n  if (value === undefined || value === null || value === '') return undefined;\n  if (typeof value === 'boolean') return value;\n  if (typeof value === 'string') {\n    const lower = value.toLowerCase();\n    if (lower === 'true' || lower === '1') return true;\n    if (lower === 'false' || lower === '0') return false;\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"]}

package/lib/utils/response.d.ts

@@ -0,0 +1,142 @@
+import { Response } from 'express';
+import { QuotaInfo } from '../types/common';
+import { ErrorCode } from '../types/error-codes';
+/**
+ * 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): void;
+/**
+ * Paginated response interface.
+ */
+export interface PaginatedResponse<T> {
+    success: true;
+    statusCode: number;
+    message?: string;
+    data: T[];
+    count: number;
+    limit: number;
+    offset: number;
+    total?: number;
+}
+/**
+ * Send a paginated list response.
+ *
+ * @param res - Express response object
+ * @param data - Array of items to return
+ * @param options - Pagination options
+ *
+ * @example
+ * ```typescript
+ * const plugins = await db.query.plugins.findMany({ limit, offset });
+ * sendPaginated(res, plugins, {
+ *   limit: 10,
+ *   offset: 0,
+ *   total: 50,
+ *   message: 'Plugins retrieved successfully',
+ * });
+ * ```
+ */
+export declare function sendPaginated<T>(res: Response, data: T[], options: {
+    limit: number;
+    offset: number;
+    total?: number;
+    message?: string;
+    statusCode?: number;
+}): 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 message string from an unknown catch value. */
+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,237 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSuccess = sendSuccess;
+exports.sendError = sendError;
+exports.sendQuotaExceeded = sendQuotaExceeded;
+exports.sendPaginated = sendPaginated;
+exports.sendPaginatedNested = sendPaginatedNested;
+exports.extractDbError = extractDbError;
+exports.errorMessage = errorMessage;
+exports.sendBadRequest = sendBadRequest;
+exports.sendInternalError = sendInternalError;
+exports.parsePaginationParams = parsePaginationParams;
+const logger_1 = require("./logger");
+const error_codes_1 = require("../types/error-codes");
+const common_schemas_1 = require("../validation/common-schemas");
+const logger = (0, logger_1.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');
+ * ```
+ */
+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' });
+ * ```
+ */
+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);
+ * ```
+ */
+function sendQuotaExceeded(res, quotaType, quota, resetAt) {
+    const resetDate = resetAt ? new Date(resetAt) : new Date();
+    const resetIn = Math.max(0, Math.ceil((resetDate.getTime() - Date.now()) / 1000));
+    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, `${quotaType} quota exceeded (${quota.used}/${quota.limit}). Please try again later.`, error_codes_1.ErrorCode.QUOTA_EXCEEDED, { quota });
+}
+/**
+ * Send a paginated list response.
+ *
+ * @param res - Express response object
+ * @param data - Array of items to return
+ * @param options - Pagination options
+ *
+ * @example
+ * ```typescript
+ * const plugins = await db.query.plugins.findMany({ limit, offset });
+ * sendPaginated(res, plugins, {
+ *   limit: 10,
+ *   offset: 0,
+ *   total: 50,
+ *   message: 'Plugins retrieved successfully',
+ * });
+ * ```
+ */
+function sendPaginated(res, data, options) {
+    if (res.headersSent) {
+        logger.warn('Attempted to send paginated response after headers already sent');
+        return;
+    }
+    const { limit, offset, total, message, statusCode = 200 } = options;
+    const response = {
+        success: true,
+        statusCode,
+        data,
+        count: data.length,
+        limit,
+        offset,
+    };
+    if (message) {
+        response.message = message;
+    }
+    if (total !== undefined) {
+        response.total = total;
+    }
+    res.status(statusCode).json(response);
+}
+/**
+ * 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 } }
+ * ```
+ */
+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({ [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);
+ * }
+ * ```
+ */
+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 message string from an unknown catch value. */
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Send a 400 bad-request response. */
+function sendBadRequest(res, message, code = error_codes_1.ErrorCode.VALIDATION_ERROR) {
+    sendError(res, 400, message, code);
+}
+/** Send a 500 internal error response. */
+function sendInternalError(res, message, details) {
+    sendError(res, 500, message, error_codes_1.ErrorCode.INTERNAL_ERROR, details);
+}
+/** Parse pagination/sort params from query string, clamping to safe defaults. */
+function parsePaginationParams(query) {
+    const limit = Math.min(Math.max(parseInt(String(query.limit), 10) || 10, 1), common_schemas_1.MAX_PAGE_LIMIT);
+    const offset = Math.max(parseInt(String(query.offset), 10) || 0, 0);
+    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 { Response } from 'express';\nimport { createLogger } from './logger';\nimport { QuotaInfo } from '../types/common';\nimport { ErrorCode } from '../types/error-codes';\nimport { MAX_PAGE_LIMIT } from '../validation/common-schemas';\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): 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  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  sendError(\n    res,\n    429,\n    `${quotaType} quota exceeded (${quota.used}/${quota.limit}). Please try again later.`,\n    ErrorCode.QUOTA_EXCEEDED,\n    { quota },\n  );\n}\n\n/**\n * Paginated response interface.\n */\nexport interface PaginatedResponse<T> {\n  success: true;\n  statusCode: number;\n  message?: string;\n  data: T[];\n  count: number;\n  limit: number;\n  offset: number;\n  total?: number;\n}\n\n/**\n * Send a paginated list response.\n *\n * @param res - Express response object\n * @param data - Array of items to return\n * @param options - Pagination options\n *\n * @example\n * ```typescript\n * const plugins = await db.query.plugins.findMany({ limit, offset });\n * sendPaginated(res, plugins, {\n *   limit: 10,\n *   offset: 0,\n *   total: 50,\n *   message: 'Plugins retrieved successfully',\n * });\n * ```\n */\nexport function sendPaginated<T>(\n  res: Response,\n  data: T[],\n  options: {\n    limit: number;\n    offset: number;\n    total?: number;\n    message?: 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\n  const { limit, offset, total, message, statusCode = 200 } = options;\n\n  const response: PaginatedResponse<T> = {\n    success: true,\n    statusCode,\n    data,\n    count: data.length,\n    limit,\n    offset,\n  };\n\n  if (message) {\n    response.message = message;\n  }\n\n  if (total !== undefined) {\n    response.total = total;\n  }\n\n  res.status(statusCode).json(response);\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({ [dataKey]: data, pagination });\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/** Extract a message string from an unknown catch value. */\nexport function errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(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  const offset = Math.max(parseInt(String(query.offset), 10) || 0, 0);\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/validation/ai-schemas.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+/**
+ * Schema for AI generation request body.
+ * Used by both POST /pipelines/generate and POST /plugins/generate.
+ */
+export declare const AIGenerateBodySchema: z.ZodObject<{
+    prompt: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    previousConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    fallbackProviders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** Validated type for AI generation request body. */
+export type ValidatedAIGenerateBody = z.infer<typeof AIGenerateBodySchema>;
+/**
+ * Schema for POST /plugins/deploy-generated request body.
+ * Validates the AI-generated plugin configuration before Docker build.
+ */
+export declare const PluginDeployGeneratedSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodString;
+    pluginType: z.ZodDefault<z.ZodEnum<{
+        CodeBuildStep: "CodeBuildStep";
+        ShellStep: "ShellStep";
+        ManualApprovalStep: "ManualApprovalStep";
+    }>>;
+    computeType: z.ZodDefault<z.ZodEnum<{
+        SMALL: "SMALL";
+        MEDIUM: "MEDIUM";
+        LARGE: "LARGE";
+        X2_LARGE: "X2_LARGE";
+    }>>;
+    keywords: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    primaryOutputDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    installCommands: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    commands: z.ZodArray<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    buildArgs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    dockerfile: z.ZodString;
+    accessModifier: z.ZodDefault<z.ZodEnum<{
+        public: "public";
+        private: "private";
+    }>>;
+}, z.core.$strip>;
+/** Validated type for plugin deploy-generated request body. */
+export type ValidatedPluginDeployGenerated = z.infer<typeof PluginDeployGeneratedSchema>;
+/**
+ * Schema for POST /pipelines/generate/from-url/stream request body.
+ * Validates Git URL + AI provider configuration for repo-based pipeline generation.
+ */
+export declare const AIGenerateFromUrlBodySchema: z.ZodObject<{
+    gitUrl: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    repoToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Validated type for AI generate-from-URL request body. */
+export type ValidatedAIGenerateFromUrlBody = z.infer<typeof AIGenerateFromUrlBodySchema>;