@pipeline-builder/api-core 0.0.1

package/lib/utils/logger.js

@@ -0,0 +1,174 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import winston from 'winston';
+import { safeCreateRequire } from './safe-require.js';
+const { combine, timestamp, printf, colorize, errors, json } = winston.format;
+// ESM has no global `require`; safeCreateRequire enables the synchronous,
+// OPTIONAL lazy-load of @opentelemetry/api in getCurrentTraceId() below — a
+// winston format callback must stay synchronous, so a dynamic import() won't
+// work there. (CJS-bundle safe — see safe-require.ts.)
+const require = safeCreateRequire(import.meta.url);
+/**
+ * Custom log format for human-readable console output.
+ */
+const consoleFormat = printf(({ level, message, timestamp, service, ...meta }) => {
+    const serviceName = service ? `[${service}]` : '';
+    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.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.
+    // Degrade to a placeholder rather than the raw subtree: returning `value` here
+    // would log a secret-keyed field nested deeper than the cap in cleartext.
+    if (depth > 6)
+        return '[TRUNCATED]';
+    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;
+}
+/**
+ * Redact sensitive values from an ARBITRARY payload using the same key-pattern
+ * rules the Winston `redactFormat` applies to log metadata. Use this for
+ * payloads that reach an output channel OUTSIDE the logger — e.g. an SSE frame
+ * pushed straight to a client — so a `password`/`token`/`secret` field is
+ * masked there too. A top-level sensitive key is masked; nested objects/arrays
+ * are walked (depth-capped) exactly as in the logger. Returns a redacted COPY;
+ * primitives pass through unchanged.
+ */
+export function redactSensitive(value) {
+    if (value == null || typeof value !== 'object')
+        return value;
+    return redactDeep(value);
+}
+/** Winston format that masks values for sensitive-looking keys (PII / secrets).
+ * Mutates `info` in place so winston's internal Symbol-keyed properties
+ * (`Symbol.for('level')`, `Symbol.for('message')`, `Symbol.for('splat')`) survive
+ * — rebuilding a fresh object via `Object.entries`/spread silently strips them,
+ * which makes the Console transport drop every entry without warning. */
+const PRESERVED_KEYS = new Set(['level', 'message', 'timestamp', 'service', 'trace_id']);
+const redactFormat = winston.format((info) => {
+    for (const key of Object.keys(info)) {
+        if (PRESERVED_KEYS.has(key))
+            continue;
+        if (SENSITIVE_KEY_PATTERN.test(key)) {
+            info[key] = REDACTED;
+        }
+        else {
+            info[key] = redactDeep(info[key]);
+        }
+    }
+    return info;
+})();
+/**
+ * Create a logger instance for a service.
+ *
+ * When LOG_FORMAT=json (default), outputs structured JSON for Loki ingestion:
+ *   {"level":"info","message":"Server started","service":"pipeline","timestamp":"..."}
+ *
+ * When LOG_FORMAT=text, outputs colorized human-readable format:
+ *   2026-02-13T10:30:00.000Z info [pipeline] Server started
+ *
+ * @param serviceName - Name of the service for log identification
+ * @returns Configured Winston logger instance
+ *
+ * @example
+ * ```typescript
+ * import { createLogger } from '@pipeline-builder/api-core';
+ *
+ * const logger = createLogger('get-plugin');
+ * logger.info('Server started', { port: 3000 });
+ * logger.error('Database error', { error: err.message });
+ * ```
+ */
+export function createLogger(serviceName) {
+    const logLevel = process.env.LOG_LEVEL || 'info';
+    const logFormat = process.env.LOG_FORMAT || 'json';
+    if (logFormat !== 'json' && logFormat !== 'text') {
+        // eslint-disable-next-line no-console -- startup warning before logger is available
+        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.createLogger({
+            level: logLevel,
+            defaultMeta: { service: serviceName },
+            format: combine(...baseFormats, json()),
+            transports: [new winston.transports.Console()],
+        });
+    }
+    return winston.createLogger({
+        level: logLevel,
+        defaultMeta: { service: serviceName },
+        format: combine(...baseFormats),
+        transports: [
+            new winston.transports.Console({
+                format: combine(colorize(), consoleFormat),
+            }),
+        ],
+    });
+}
+/**
+ * Default logger instance (service name from SERVICE_NAME env var or 'api').
+ */
+export const logger = createLogger(process.env.SERVICE_NAME || 'api');
+export default logger;
+//# 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';\nimport { safeCreateRequire } from './safe-require.js';\n\nconst { combine, timestamp, printf, colorize, errors, json } = winston.format;\n\n// ESM has no global `require`; safeCreateRequire enables the synchronous,\n// OPTIONAL lazy-load of @opentelemetry/api in getCurrentTraceId() below — a\n// winston format callback must stay synchronous, so a dynamic import() won't\n// work there. (CJS-bundle safe — see safe-require.ts.)\nconst require = safeCreateRequire(import.meta.url);\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  // Degrade to a placeholder rather than the raw subtree: returning `value` here\n  // would log a secret-keyed field nested deeper than the cap in cleartext.\n  if (depth > 6) return '[TRUNCATED]';\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/**\n * Redact sensitive values from an ARBITRARY payload using the same key-pattern\n * rules the Winston `redactFormat` applies to log metadata. Use this for\n * payloads that reach an output channel OUTSIDE the logger — e.g. an SSE frame\n * pushed straight to a client — so a `password`/`token`/`secret` field is\n * masked there too. A top-level sensitive key is masked; nested objects/arrays\n * are walked (depth-capped) exactly as in the logger. Returns a redacted COPY;\n * primitives pass through unchanged.\n */\nexport function redactSensitive(value: unknown): unknown {\n  if (value == null || typeof value !== 'object') return value;\n  return redactDeep(value);\n}\n\n/** Winston format that masks values for sensitive-looking keys (PII / secrets).\n * Mutates `info` in place so winston's internal Symbol-keyed properties\n * (`Symbol.for('level')`, `Symbol.for('message')`, `Symbol.for('splat')`) survive\n * — rebuilding a fresh object via `Object.entries`/spread silently strips them,\n * which makes the Console transport drop every entry without warning. */\nconst PRESERVED_KEYS = new Set(['level', 'message', 'timestamp', 'service', 'trace_id']);\nconst redactFormat = winston.format((info) => {\n  for (const key of Object.keys(info)) {\n    if (PRESERVED_KEYS.has(key)) continue;\n    if (SENSITIVE_KEY_PATTERN.test(key)) {\n      info[key] = REDACTED;\n    } else {\n      info[key] = redactDeep(info[key]);\n    }\n  }\n  return info;\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/lib/utils/metric-emitter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pluggable counter-emit shim.
+ *
+ * Background: several api-core primitives (quota client fail-open, future
+ * security-event hooks) want to record Prometheus counters when something
+ * notable happens. The actual `prom-client` Counter registration lives in
+ * api-server, and api-core must not depend on api-server (api-core is
+ * upstream — Express infrastructure imports it, not the other way around).
+ *
+ * This module is the seam. api-core code calls `emitCounter(name, labels)`;
+ * by default it's a no-op (tests, CLIs, environments without Prometheus).
+ * api-server's app-factory calls `setCounterEmitter(incCounter)` at startup
+ * so production processes start incrementing the real counter on the
+ * shared registry.
+ *
+ * Why a callback instead of an interface registered via DI? The call sites
+ * (quota fail-open, etc.) sit in deep helpers that never touch the Express
+ * context, so requiring a `metrics` parameter on every call would mean
+ * threading it through dozens of unrelated functions. A process-singleton
+ * callback is the simplest non-invasive option; the trade-off is one
+ * shared global, which is acceptable for a sink that's strictly write-only.
+ */
+/** Callable signature mirroring api-server's `incCounter`. */
+export type CounterEmitter = (name: string, labels?: Record<string, string>, value?: number) => void;
+/**
+ * Register the real counter implementation. Idempotent — the last call wins;
+ * typically called once at service startup from api-server.
+ */
+export declare function setCounterEmitter(fn: CounterEmitter): void;
+/** Reset to the no-op emitter. For tests that want to clear any wiring. */
+export declare function resetCounterEmitter(): void;
+/**
+ * Record a counter event. Safe to call from any api-core module — if no
+ * emitter is wired, this is a no-op.
+ */
+export declare function emitCounter(name: string, labels?: Record<string, string>, value?: number): void;

package/lib/utils/metric-emitter.js

@@ -0,0 +1,32 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+let emitter = () => {
+    // Default no-op. api-server wires this to a real Prometheus counter at
+    // startup; until then, calls from api-core helpers are silently dropped
+    // (which is what we want in tests and CLIs that don't run a Prom server).
+};
+/**
+ * Register the real counter implementation. Idempotent — the last call wins;
+ * typically called once at service startup from api-server.
+ */
+export function setCounterEmitter(fn) {
+    emitter = fn;
+}
+/** Reset to the no-op emitter. For tests that want to clear any wiring. */
+export function resetCounterEmitter() {
+    emitter = () => undefined;
+}
+/**
+ * Record a counter event. Safe to call from any api-core module — if no
+ * emitter is wired, this is a no-op.
+ */
+export function emitCounter(name, labels = {}, value = 1) {
+    try {
+        emitter(name, labels, value);
+    }
+    catch {
+        // Never let metric emission break the calling path. A misbehaving
+        // emitter shouldn't be able to take down quota checks (or anything else).
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0cmljLWVtaXR0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvbWV0cmljLWVtaXR0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQTRCdEMsSUFBSSxPQUFPLEdBQW1CLEdBQUcsRUFBRTtJQUNqQyx1RUFBdUU7SUFDdkUsd0VBQXdFO0lBQ3hFLDBFQUEwRTtBQUM1RSxDQUFDLENBQUM7QUFFRjs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsaUJBQWlCLENBQUMsRUFBa0I7SUFDbEQsT0FBTyxHQUFHLEVBQUUsQ0FBQztBQUNmLENBQUM7QUFFRCwyRUFBMkU7QUFDM0UsTUFBTSxVQUFVLG1CQUFtQjtJQUNqQyxPQUFPLEdBQUcsR0FBRyxFQUFFLENBQUMsU0FBUyxDQUFDO0FBQzVCLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsV0FBVyxDQUFDLElBQVksRUFBRSxNQUFNLEdBQTJCLEVBQUUsRUFBRSxLQUFLLEdBQUcsQ0FBQztJQUN0RixJQUFJLENBQUM7UUFDSCxPQUFPLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztJQUMvQixDQUFDO0lBQUMsTUFBTSxDQUFDO1FBQ1Asa0VBQWtFO1FBQ2xFLDBFQUEwRTtJQUM1RSxDQUFDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFBsdWdnYWJsZSBjb3VudGVyLWVtaXQgc2hpbS5cbiAqXG4gKiBCYWNrZ3JvdW5kOiBzZXZlcmFsIGFwaS1jb3JlIHByaW1pdGl2ZXMgKHF1b3RhIGNsaWVudCBmYWlsLW9wZW4sIGZ1dHVyZVxuICogc2VjdXJpdHktZXZlbnQgaG9va3MpIHdhbnQgdG8gcmVjb3JkIFByb21ldGhldXMgY291bnRlcnMgd2hlbiBzb21ldGhpbmdcbiAqIG5vdGFibGUgaGFwcGVucy4gVGhlIGFjdHVhbCBgcHJvbS1jbGllbnRgIENvdW50ZXIgcmVnaXN0cmF0aW9uIGxpdmVzIGluXG4gKiBhcGktc2VydmVyLCBhbmQgYXBpLWNvcmUgbXVzdCBub3QgZGVwZW5kIG9uIGFwaS1zZXJ2ZXIgKGFwaS1jb3JlIGlzXG4gKiB1cHN0cmVhbSDigJQgRXhwcmVzcyBpbmZyYXN0cnVjdHVyZSBpbXBvcnRzIGl0LCBub3QgdGhlIG90aGVyIHdheSBhcm91bmQpLlxuICpcbiAqIFRoaXMgbW9kdWxlIGlzIHRoZSBzZWFtLiBhcGktY29yZSBjb2RlIGNhbGxzIGBlbWl0Q291bnRlcihuYW1lLCBsYWJlbHMpYDtcbiAqIGJ5IGRlZmF1bHQgaXQncyBhIG5vLW9wICh0ZXN0cywgQ0xJcywgZW52aXJvbm1lbnRzIHdpdGhvdXQgUHJvbWV0aGV1cykuXG4gKiBhcGktc2VydmVyJ3MgYXBwLWZhY3RvcnkgY2FsbHMgYHNldENvdW50ZXJFbWl0dGVyKGluY0NvdW50ZXIpYCBhdCBzdGFydHVwXG4gKiBzbyBwcm9kdWN0aW9uIHByb2Nlc3NlcyBzdGFydCBpbmNyZW1lbnRpbmcgdGhlIHJlYWwgY291bnRlciBvbiB0aGVcbiAqIHNoYXJlZCByZWdpc3RyeS5cbiAqXG4gKiBXaHkgYSBjYWxsYmFjayBpbnN0ZWFkIG9mIGFuIGludGVyZmFjZSByZWdpc3RlcmVkIHZpYSBEST8gVGhlIGNhbGwgc2l0ZXNcbiAqIChxdW90YSBmYWlsLW9wZW4sIGV0Yy4pIHNpdCBpbiBkZWVwIGhlbHBlcnMgdGhhdCBuZXZlciB0b3VjaCB0aGUgRXhwcmVzc1xuICogY29udGV4dCwgc28gcmVxdWlyaW5nIGEgYG1ldHJpY3NgIHBhcmFtZXRlciBvbiBldmVyeSBjYWxsIHdvdWxkIG1lYW5cbiAqIHRocmVhZGluZyBpdCB0aHJvdWdoIGRvemVucyBvZiB1bnJlbGF0ZWQgZnVuY3Rpb25zLiBBIHByb2Nlc3Mtc2luZ2xldG9uXG4gKiBjYWxsYmFjayBpcyB0aGUgc2ltcGxlc3Qgbm9uLWludmFzaXZlIG9wdGlvbjsgdGhlIHRyYWRlLW9mZiBpcyBvbmVcbiAqIHNoYXJlZCBnbG9iYWwsIHdoaWNoIGlzIGFjY2VwdGFibGUgZm9yIGEgc2luayB0aGF0J3Mgc3RyaWN0bHkgd3JpdGUtb25seS5cbiAqL1xuXG4vKiogQ2FsbGFibGUgc2lnbmF0dXJlIG1pcnJvcmluZyBhcGktc2VydmVyJ3MgYGluY0NvdW50ZXJgLiAqL1xuZXhwb3J0IHR5cGUgQ291bnRlckVtaXR0ZXIgPSAobmFtZTogc3RyaW5nLCBsYWJlbHM/OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+LCB2YWx1ZT86IG51bWJlcikgPT4gdm9pZDtcblxubGV0IGVtaXR0ZXI6IENvdW50ZXJFbWl0dGVyID0gKCkgPT4ge1xuICAvLyBEZWZhdWx0IG5vLW9wLiBhcGktc2VydmVyIHdpcmVzIHRoaXMgdG8gYSByZWFsIFByb21ldGhldXMgY291bnRlciBhdFxuICAvLyBzdGFydHVwOyB1bnRpbCB0aGVuLCBjYWxscyBmcm9tIGFwaS1jb3JlIGhlbHBlcnMgYXJlIHNpbGVudGx5IGRyb3BwZWRcbiAgLy8gKHdoaWNoIGlzIHdoYXQgd2Ugd2FudCBpbiB0ZXN0cyBhbmQgQ0xJcyB0aGF0IGRvbid0IHJ1biBhIFByb20gc2VydmVyKS5cbn07XG5cbi8qKlxuICogUmVnaXN0ZXIgdGhlIHJlYWwgY291bnRlciBpbXBsZW1lbnRhdGlvbi4gSWRlbXBvdGVudCDigJQgdGhlIGxhc3QgY2FsbCB3aW5zO1xuICogdHlwaWNhbGx5IGNhbGxlZCBvbmNlIGF0IHNlcnZpY2Ugc3RhcnR1cCBmcm9tIGFwaS1zZXJ2ZXIuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzZXRDb3VudGVyRW1pdHRlcihmbjogQ291bnRlckVtaXR0ZXIpOiB2b2lkIHtcbiAgZW1pdHRlciA9IGZuO1xufVxuXG4vKiogUmVzZXQgdG8gdGhlIG5vLW9wIGVtaXR0ZXIuIEZvciB0ZXN0cyB0aGF0IHdhbnQgdG8gY2xlYXIgYW55IHdpcmluZy4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZXNldENvdW50ZXJFbWl0dGVyKCk6IHZvaWQge1xuICBlbWl0dGVyID0gKCkgPT4gdW5kZWZpbmVkO1xufVxuXG4vKipcbiAqIFJlY29yZCBhIGNvdW50ZXIgZXZlbnQuIFNhZmUgdG8gY2FsbCBmcm9tIGFueSBhcGktY29yZSBtb2R1bGUg4oCUIGlmIG5vXG4gKiBlbWl0dGVyIGlzIHdpcmVkLCB0aGlzIGlzIGEgbm8tb3AuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBlbWl0Q291bnRlcihuYW1lOiBzdHJpbmcsIGxhYmVsczogUmVjb3JkPHN0cmluZywgc3RyaW5nPiA9IHt9LCB2YWx1ZSA9IDEpOiB2b2lkIHtcbiAgdHJ5IHtcbiAgICBlbWl0dGVyKG5hbWUsIGxhYmVscywgdmFsdWUpO1xuICB9IGNhdGNoIHtcbiAgICAvLyBOZXZlciBsZXQgbWV0cmljIGVtaXNzaW9uIGJyZWFrIHRoZSBjYWxsaW5nIHBhdGguIEEgbWlzYmVoYXZpbmdcbiAgICAvLyBlbWl0dGVyIHNob3VsZG4ndCBiZSBhYmxlIHRvIHRha2UgZG93biBxdW90YSBjaGVja3MgKG9yIGFueXRoaW5nIGVsc2UpLlxuICB9XG59XG4iXX0=

package/lib/utils/object.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Filter an object to only include entries where the value is not `undefined`.
+ * Keeps `null`, `false`, `0`, and empty string — only removes `undefined`.
+ *
+ * Useful for building partial update payloads from validated request bodies.
+ *
+ * @example
+ * ```typescript
+ * const body = { name: 'foo', description: undefined, isActive: false };
+ * pickDefined(body); // { name: 'foo', isActive: false }
+ * ```
+ */
+export declare function pickDefined<T extends Record<string, unknown>>(obj: T): Partial<T>;

package/lib/utils/object.js

@@ -0,0 +1,18 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Filter an object to only include entries where the value is not `undefined`.
+ * Keeps `null`, `false`, `0`, and empty string — only removes `undefined`.
+ *
+ * Useful for building partial update payloads from validated request bodies.
+ *
+ * @example
+ * ```typescript
+ * const body = { name: 'foo', description: undefined, isActive: false };
+ * pickDefined(body); // { name: 'foo', isActive: false }
+ * ```
+ */
+export function pickDefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL29iamVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsTUFBTSxVQUFVLFdBQVcsQ0FBb0MsR0FBTTtJQUNuRSxPQUFPLE1BQU0sQ0FBQyxXQUFXLENBQ3ZCLE1BQU0sQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEtBQUssU0FBUyxDQUFDLENBQ3pDLENBQUM7QUFDbEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIEZpbHRlciBhbiBvYmplY3QgdG8gb25seSBpbmNsdWRlIGVudHJpZXMgd2hlcmUgdGhlIHZhbHVlIGlzIG5vdCBgdW5kZWZpbmVkYC5cbiAqIEtlZXBzIGBudWxsYCwgYGZhbHNlYCwgYDBgLCBhbmQgZW1wdHkgc3RyaW5nIOKAlCBvbmx5IHJlbW92ZXMgYHVuZGVmaW5lZGAuXG4gKlxuICogVXNlZnVsIGZvciBidWlsZGluZyBwYXJ0aWFsIHVwZGF0ZSBwYXlsb2FkcyBmcm9tIHZhbGlkYXRlZCByZXF1ZXN0IGJvZGllcy5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogY29uc3QgYm9keSA9IHsgbmFtZTogJ2ZvbycsIGRlc2NyaXB0aW9uOiB1bmRlZmluZWQsIGlzQWN0aXZlOiBmYWxzZSB9O1xuICogcGlja0RlZmluZWQoYm9keSk7IC8vIHsgbmFtZTogJ2ZvbycsIGlzQWN0aXZlOiBmYWxzZSB9XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHBpY2tEZWZpbmVkPFQgZXh0ZW5kcyBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPj4ob2JqOiBUKTogUGFydGlhbDxUPiB7XG4gIHJldHVybiBPYmplY3QuZnJvbUVudHJpZXMoXG4gICAgT2JqZWN0LmVudHJpZXMob2JqKS5maWx0ZXIoKFssIHZdKSA9PiB2ICE9PSB1bmRlZmluZWQpLFxuICApIGFzIFBhcnRpYWw8VD47XG59XG4iXX0=

package/lib/utils/params.d.ts

@@ -0,0 +1,150 @@
+import type { Request } from 'express';
+/**
+ * Shape convention for the inline parse-guard helpers below.
+ *
+ * These return a lightweight `{ value } | { error }` (narrowed with
+ * `'error' in result`) — deliberately DISTINCT from the schema-validation
+ * `ValidationResult<T>` (`{ ok, value } | { ok, error }`) in
+ * `validation/middleware.ts`. Zod schema parsing uses the `ok`-discriminated
+ * shape; these ad-hoc request-parameter guards use `'error' in`. The split is
+ * intentional and documented (see the note on `ValidationResult`): converging
+ * them would churn every `'error' in result` call site across the downstream
+ * services with no behavioural change, so it's left as a documented convention.
+ */
+/**
+ * Express 5 parameter type.
+ */
+type ParamValue = string | string[] | undefined;
+/**
+ * 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 declare function getParam(params: Record<string, ParamValue>, key: string): string | undefined;
+/**
+ * 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 declare function getOrgId(req: Request): string | 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 declare function parseQueryInt(value: unknown, defaultValue: number): number;
+/**
+ * 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 declare function parseQueryString(value: unknown): string | undefined;
+/**
+ * Parse a string to a positive integer, returning a fallback if invalid.
+ * Useful for parsing environment variables with numeric defaults.
+ */
+export declare function parsePositiveInt(value: string | undefined, fallback: number): number;
+/**
+ * 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 declare function parseQueryIntClamped(value: unknown, defaultValue: number, max: number): number;
+/**
+ * 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 declare function validateBulkArray<T = unknown>(value: unknown, fieldName: string, maxItems?: number): {
+    value: T[];
+} | {
+    error: string;
+};
+/**
+ * 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 declare const REPORT_INTERVALS: readonly ['day', 'week', 'month'];
+export type ReportInterval = (typeof REPORT_INTERVALS)[number];
+/**
+ * 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 declare function parseReportInterval(query: Record<string, unknown>): ReportInterval | {
+    error: string;
+};
+/**
+ * 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 declare function parseDateRange(query: Record<string, unknown>, options?: {
+    maxRangeMs?: number;
+    defaultDaysBack?: number;
+}): {
+    from: string;
+    to: string;
+} | {
+    error: string;
+};
+export {};