@pipeline-builder/api-core 3.3.15 → 3.3.17

package/lib/middleware/index.d.ts

@@ -1 +1,2 @@
 export * from './auth';
+export * from './mongo-sanitize';

package/lib/middleware/index.js

@@ -17,4 +17,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlkZGxld2FyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsK0NBQStDO0FBQy9DLHNDQUFzQzs7Ozs7Ozs7Ozs7Ozs7OztBQUV0Qyx5Q0FBdUIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9hdXRoJztcbiJdfQ==
+__exportStar(require("./mongo-sanitize"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlkZGxld2FyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsK0NBQStDO0FBQy9DLHNDQUFzQzs7Ozs7Ozs7Ozs7Ozs7OztBQUV0Qyx5Q0FBdUI7QUFDdkIsbURBQWlDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vYXV0aCc7XG5leHBvcnQgKiBmcm9tICcuL21vbmdvLXNhbml0aXplJztcbiJdfQ==

package/lib/middleware/mongo-sanitize.d.ts

@@ -0,0 +1,19 @@
+import type { NextFunction, Request, Response } from 'express';
+/**
+ * MongoDB operator-injection middleware.
+ *
+ * Recursively strips object keys starting with `$` (Mongo operators like
+ * `$ne`, `$gt`, `$where`) and keys containing `.` (dot-walks) from
+ * `req.body`, `req.query`, and `req.params`. Without this, a JSON request
+ * like `{"email": {"$ne": null}}` against a Mongo-backed service can match
+ * any document — Zod catches the wrong *type* but won't reach into nested
+ * objects to strip operator-shaped keys.
+ *
+ * Apply BEFORE any Mongo query handler (typically right after
+ * `express.json()`). Postgres-backed services don't need it.
+ *
+ * Modifies in place. On Express 5+ where `req.query` is a read-only getter,
+ * this still works because we mutate the underlying object's keys, not the
+ * reference.
+ */
+export declare function mongoSanitize(): (req: Request, _res: Response, next: NextFunction) => void;

package/lib/middleware/mongo-sanitize.js

@@ -0,0 +1,57 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoSanitize = mongoSanitize;
+/**
+ * MongoDB operator-injection middleware.
+ *
+ * Recursively strips object keys starting with `$` (Mongo operators like
+ * `$ne`, `$gt`, `$where`) and keys containing `.` (dot-walks) from
+ * `req.body`, `req.query`, and `req.params`. Without this, a JSON request
+ * like `{"email": {"$ne": null}}` against a Mongo-backed service can match
+ * any document — Zod catches the wrong *type* but won't reach into nested
+ * objects to strip operator-shaped keys.
+ *
+ * Apply BEFORE any Mongo query handler (typically right after
+ * `express.json()`). Postgres-backed services don't need it.
+ *
+ * Modifies in place. On Express 5+ where `req.query` is a read-only getter,
+ * this still works because we mutate the underlying object's keys, not the
+ * reference.
+ */
+function mongoSanitize() {
+    return (req, _res, next) => {
+        if (req.body && typeof req.body === 'object')
+            sanitizeObject(req.body);
+        if (req.query && typeof req.query === 'object')
+            sanitizeObject(req.query);
+        if (req.params && typeof req.params === 'object')
+            sanitizeObject(req.params);
+        next();
+    };
+}
+function sanitizeObject(obj, depth = 0) {
+    // Cap depth — defense against pathological nested input.
+    if (depth > 10)
+        return;
+    for (const key of Object.keys(obj)) {
+        if (key.startsWith('$') || key.includes('.')) {
+            delete obj[key];
+            continue;
+        }
+        const v = obj[key];
+        if (v && typeof v === 'object') {
+            if (Array.isArray(v)) {
+                for (const item of v) {
+                    if (item && typeof item === 'object')
+                        sanitizeObject(item, depth + 1);
+                }
+            }
+            else {
+                sanitizeObject(v, depth + 1);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/logger.js

@@ -17,6 +17,71 @@ const consoleFormat = printf(({ level, message, timestamp, service, ...meta }) =
     const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
     return `${timestamp} ${level} ${serviceName} ${message}${metaStr}`;
 });
+/**
+ * Lazy lookup of OpenTelemetry trace ID. Returns undefined when tracing
+ * isn't initialized or @opentelemetry/api isn't installed — never throws.
+ * Cheap: a single property read after the first successful lookup.
+ */
+let _otelApi;
+function getCurrentTraceId() {
+    if (_otelApi === undefined) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            _otelApi = require('@opentelemetry/api');
+        }
+        catch {
+            _otelApi = null;
+        }
+    }
+    if (!_otelApi)
+        return undefined;
+    try {
+        return _otelApi.trace?.getActiveSpan()?.spanContext().traceId;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Winston format that stamps `trace_id` on every entry when an OTel span is active. */
+const traceIdFormat = winston_1.default.format((info) => {
+    const traceId = getCurrentTraceId();
+    if (traceId)
+        info.trace_id = traceId;
+    return info;
+})();
+/**
+ * Keys that should never appear in logs. Match is case-insensitive and
+ * anchored substring — `Authorization`, `auth_header`, `MY_PASSWORD` all hit.
+ * Add a new term here only if you've seen real-world leakage; over-redaction
+ * makes incident debugging harder.
+ */
+const SENSITIVE_KEY_PATTERN = /password|secret|bearer|api[_-]?key|cookie|token|^auth(orization|_header)?$|stripe[_-]?(key|secret)|mongo(db)?[_-]?uri/i;
+const REDACTED = '[REDACTED]';
+function redactDeep(value, depth = 0) {
+    // Cap depth so a malicious / pathological circular object can't lock the logger.
+    if (depth > 6)
+        return value;
+    if (value == null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map((v) => redactDeep(v, depth + 1));
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (SENSITIVE_KEY_PATTERN.test(k)) {
+            out[k] = REDACTED;
+        }
+        else {
+            out[k] = redactDeep(v, depth + 1);
+        }
+    }
+    return out;
+}
+/** Winston format that masks values for sensitive-looking keys (PII / secrets). */
+const redactFormat = winston_1.default.format((info) => {
+    const { level, message, timestamp, service, trace_id, ...meta } = info;
+    const safe = redactDeep(meta);
+    return { level, message, timestamp, service, trace_id, ...safe };
+})();
 /**
  * Create a logger instance for a service.
  *
@@ -46,9 +111,13 @@ function createLogger(serviceName) {
         console.warn(`Invalid LOG_FORMAT="${logFormat}", expected "json" or "text". Defaulting to "json".`);
     }
     const useJson = logFormat !== 'text';
+    // Order matters: redact BEFORE serialization so masked keys never reach
+    // the output. trace_id is stamped first so it survives redaction.
     const baseFormats = [
         errors({ stack: true }),
         timestamp({ format: 'YYYY-MM-DDTHH:mm:ss.SSSZ' }),
+        traceIdFormat,
+        redactFormat,
     ];
     if (useJson) {
         return winston_1.default.createLogger({
@@ -74,4 +143,4 @@ function createLogger(serviceName) {
  */
 exports.logger = createLogger(process.env.SERVICE_NAME || 'api');
 exports.default = exports.logger;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport winston from 'winston';\n\nconst { combine, timestamp, printf, colorize, errors, json } = winston.format;\n\n/**\n * Custom log format for human-readable console output.\n */\nconst consoleFormat = printf(({ level, message, timestamp, service, ...meta }) => {\n  const serviceName = service ? `[${service}]` : '';\n  const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';\n  return `${timestamp} ${level} ${serviceName} ${message}${metaStr}`;\n});\n\n/**\n * Lazy lookup of OpenTelemetry trace ID. Returns undefined when tracing\n * isn't initialized or @opentelemetry/api isn't installed — never throws.\n * Cheap: a single property read after the first successful lookup.\n */\nlet _otelApi: { trace?: { getActiveSpan(): { spanContext(): { traceId: string } } | undefined } } | null | undefined;\nfunction getCurrentTraceId(): string | undefined {\n  if (_otelApi === undefined) {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      _otelApi = require('@opentelemetry/api');\n    } catch {\n      _otelApi = null;\n    }\n  }\n  if (!_otelApi) return undefined;\n  try {\n    return _otelApi.trace?.getActiveSpan()?.spanContext().traceId;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Winston format that stamps `trace_id` on every entry when an OTel span is active. */\nconst traceIdFormat = winston.format((info) => {\n  const traceId = getCurrentTraceId();\n  if (traceId) info.trace_id = traceId;\n  return info;\n})();\n\n/**\n * Keys that should never appear in logs. Match is case-insensitive and\n * anchored substring — `Authorization`, `auth_header`, `MY_PASSWORD` all hit.\n * Add a new term here only if you've seen real-world leakage; over-redaction\n * makes incident debugging harder.\n */\nconst SENSITIVE_KEY_PATTERN = /password|secret|bearer|api[_-]?key|cookie|token|^auth(orization|_header)?$|stripe[_-]?(key|secret)|mongo(db)?[_-]?uri/i;\nconst REDACTED = '[REDACTED]';\n\nfunction redactDeep(value: unknown, depth = 0): unknown {\n  // Cap depth so a malicious / pathological circular object can't lock the logger.\n  if (depth > 6) return value;\n  if (value == null || typeof value !== 'object') return value;\n  if (Array.isArray(value)) return value.map((v) => redactDeep(v, depth + 1));\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {\n    if (SENSITIVE_KEY_PATTERN.test(k)) {\n      out[k] = REDACTED;\n    } else {\n      out[k] = redactDeep(v, depth + 1);\n    }\n  }\n  return out;\n}\n\n/** Winston format that masks values for sensitive-looking keys (PII / secrets). */\nconst redactFormat = winston.format((info) => {\n  const { level, message, timestamp, service, trace_id, ...meta } = info;\n  const safe = redactDeep(meta) as Record<string, unknown>;\n  return { level, message, timestamp, service, trace_id, ...safe };\n})();\n\n/**\n * Create a logger instance for a service.\n *\n * When LOG_FORMAT=json (default), outputs structured JSON for Loki ingestion:\n *   {\"level\":\"info\",\"message\":\"Server started\",\"service\":\"pipeline\",\"timestamp\":\"...\"}\n *\n * When LOG_FORMAT=text, outputs colorized human-readable format:\n *   2026-02-13T10:30:00.000Z info [pipeline] Server started\n *\n * @param serviceName - Name of the service for log identification\n * @returns Configured Winston logger instance\n *\n * @example\n * ```typescript\n * import { createLogger } from '@pipeline-builder/api-core';\n *\n * const logger = createLogger('get-plugin');\n * logger.info('Server started', { port: 3000 });\n * logger.error('Database error', { error: err.message });\n * ```\n */\nexport function createLogger(serviceName: string): winston.Logger {\n  const logLevel = process.env.LOG_LEVEL || 'info';\n  const logFormat = process.env.LOG_FORMAT || 'json';\n  if (logFormat !== 'json' && logFormat !== 'text') {\n    // eslint-disable-next-line no-console -- startup warning before logger is available\n    console.warn(`Invalid LOG_FORMAT=\"${logFormat}\", expected \"json\" or \"text\". Defaulting to \"json\".`);\n  }\n  const useJson = logFormat !== 'text';\n\n  // Order matters: redact BEFORE serialization so masked keys never reach\n  // the output. trace_id is stamped first so it survives redaction.\n  const baseFormats = [\n    errors({ stack: true }),\n    timestamp({ format: 'YYYY-MM-DDTHH:mm:ss.SSSZ' }),\n    traceIdFormat,\n    redactFormat,\n  ];\n\n  if (useJson) {\n    return winston.createLogger({\n      level: logLevel,\n      defaultMeta: { service: serviceName },\n      format: combine(...baseFormats, json()),\n      transports: [new winston.transports.Console()],\n    });\n  }\n\n  return winston.createLogger({\n    level: logLevel,\n    defaultMeta: { service: serviceName },\n    format: combine(...baseFormats),\n    transports: [\n      new winston.transports.Console({\n        format: combine(colorize(), consoleFormat),\n      }),\n    ],\n  });\n}\n\n/**\n * Default logger instance (service name from SERVICE_NAME env var or 'api').\n */\nexport const logger = createLogger(process.env.SERVICE_NAME || 'api');\n\nexport default logger;\n"]}

package/package.json

@@ -66,7 +66,7 @@
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "homepage": "https://mwashburn160.github.io/pipeline-builder/",
-  "version": "3.3.15",
+  "version": "3.3.17",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },