unnbound-events 1.0.19 → 1.0.21

package/dist/logger/src/index.js

@@ -1,14 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.traceMiddleware = exports.traceAxios = exports.startSpan = exports.getTraceId = exports.withTrace = exports.logger = void 0;
-var logger_1 = require("./logger");
-Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
-var trace_1 = require("./trace");
-Object.defineProperty(exports, "withTrace", { enumerable: true, get: function () { return trace_1.withTrace; } });
-Object.defineProperty(exports, "getTraceId", { enumerable: true, get: function () { return trace_1.getTraceId; } });
-var span_1 = require("./span");
-Object.defineProperty(exports, "startSpan", { enumerable: true, get: function () { return span_1.startSpan; } });
-var axios_1 = require("./axios");
-Object.defineProperty(exports, "traceAxios", { enumerable: true, get: function () { return axios_1.traceAxios; } });
-var middleware_1 = require("./middleware");
-Object.defineProperty(exports, "traceMiddleware", { enumerable: true, get: function () { return middleware_1.traceMiddleware; } });
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.traceMiddleware =
+  exports.traceAxios =
+  exports.startSpan =
+  exports.getTraceId =
+  exports.withTrace =
+  exports.logger =
+    void 0;
+var logger_1 = require('./logger');
+Object.defineProperty(exports, 'logger', {
+  enumerable: true,
+  get: function () {
+    return logger_1.logger;
+  },
+});
+var trace_1 = require('./trace');
+Object.defineProperty(exports, 'withTrace', {
+  enumerable: true,
+  get: function () {
+    return trace_1.withTrace;
+  },
+});
+Object.defineProperty(exports, 'getTraceId', {
+  enumerable: true,
+  get: function () {
+    return trace_1.getTraceId;
+  },
+});
+var span_1 = require('./span');
+Object.defineProperty(exports, 'startSpan', {
+  enumerable: true,
+  get: function () {
+    return span_1.startSpan;
+  },
+});
+var axios_1 = require('./axios');
+Object.defineProperty(exports, 'traceAxios', {
+  enumerable: true,
+  get: function () {
+    return axios_1.traceAxios;
+  },
+});
+var middleware_1 = require('./middleware');
+Object.defineProperty(exports, 'traceMiddleware', {
+  enumerable: true,
+  get: function () {
+    return middleware_1.traceMiddleware;
+  },
+});

package/dist/logger/src/logger.d.ts

@@ -1,15 +1,21 @@
 import pino from 'pino';
-export interface UnnboundLogger extends Omit<pino.Logger, 'trace' | 'debug' | 'error' | 'info' | 'warn'> {
-    trace(object: {}, message: string): void;
-    trace(message: string): void;
-    debug(object: {}, message: string): void;
-    debug(message: string): void;
-    info(object: {}, message: string): void;
-    info(message: string): void;
-    warn(object: {}, message: string): void;
-    warn(message: string): void;
-    error<O extends {
-        err: unknown;
-    }>(object: O, message: string): void;
+export interface UnnboundLogger
+  extends Omit<pino.Logger, 'trace' | 'debug' | 'error' | 'info' | 'warn'> {
+  trace(object: {}, message: string): void;
+  trace(message: string): void;
+  debug(object: {}, message: string): void;
+  debug(message: string): void;
+  info(object: {}, message: string): void;
+  info(message: string): void;
+  warn(object: {}, message: string): void;
+  warn(message: string): void;
+  error<
+    O extends {
+      err: unknown;
+    },
+  >(
+    object: O,
+    message: string
+  ): void;
 }
 export declare const logger: UnnboundLogger;

package/dist/logger/src/logger.js

@@ -1,44 +1,46 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.logger = void 0;
-const pino_1 = __importDefault(require("pino"));
-const uuid_1 = require("uuid");
-const storage_1 = require("./storage");
+const pino_1 = __importDefault(require('pino'));
+const uuid_1 = require('uuid');
+const storage_1 = require('./storage');
 exports.logger = (0, pino_1.default)({
-    level: process.env.LOG_LEVEL ?? 'info',
-    base: {
-        environment: process.env.ENVIRONMENT,
-        workflowId: process.env.UNNBOUND_WORKFLOW_ID,
-        serviceId: process.env.UNNBOUND_SERVICE_ID,
-        deploymentId: process.env.UNNBOUND_DEPLOYMENT_ID,
-    },
-    mixin: () => ({ ...storage_1.storage.getStore(), logId: (0, uuid_1.v4)() }),
-    serializers: {
-        req: pino_1.default.stdSerializers.req,
-        res: pino_1.default.stdSerializers.res,
-        err: pino_1.default.stdSerializers.err,
-    },
-    // Let CloudWatch handle timestamps
-    timestamp: false,
-    // Change message field from 'msg' to 'message'
-    messageKey: 'message',
-    formatters: {
-        level: (level) => ({ level }),
-    },
-    redact: {
-        paths: [
-            'http.request.headers.authorization',
-            'http.response.headers.authorization',
-            'http.request.headers.Authorization',
-            'http.response.headers.Authorization',
-            'err.config',
-        ],
-        remove: true,
-    },
+  level: process.env.LOG_LEVEL ?? 'info',
+  base: {
+    environment: process.env.ENVIRONMENT,
+    workflowId: process.env.UNNBOUND_WORKFLOW_ID,
+    serviceId: process.env.UNNBOUND_SERVICE_ID,
+    deploymentId: process.env.UNNBOUND_DEPLOYMENT_ID,
+  },
+  mixin: () => ({ ...storage_1.storage.getStore(), logId: (0, uuid_1.v4)() }),
+  serializers: {
+    req: pino_1.default.stdSerializers.req,
+    res: pino_1.default.stdSerializers.res,
+    err: pino_1.default.stdSerializers.err,
+  },
+  // Let CloudWatch handle timestamps
+  timestamp: false,
+  // Change message field from 'msg' to 'message'
+  messageKey: 'message',
+  formatters: {
+    level: (level) => ({ level }),
+  },
+  redact: {
+    paths: [
+      'http.request.headers.authorization',
+      'http.response.headers.authorization',
+      'http.request.headers.Authorization',
+      'http.response.headers.Authorization',
+      'err.config',
+    ],
+    remove: true,
+  },
 });
 process.on('uncaughtException', (err, origin) => {
-    exports.logger.error({ err, origin }, `Uncaught exception.`);
+  exports.logger.error({ err, origin }, `Uncaught exception.`);
 });

package/dist/logger/src/middleware.d.ts

@@ -1,10 +1,6 @@
-import { Request, RequestHandler } from 'express';
+import { RequestHandler } from 'express';
 import { HttpOptions } from './types';
-interface Response {
-    status: number;
-    headers?: Record<string, string | undefined>;
-    body?: unknown;
-}
-type GetPayload = (config: Request, res?: Response) => object;
-export declare const traceMiddleware: ({ ignoreTraceRoutes, traceHeaderKey, getPayload, }?: HttpOptions<GetPayload>) => RequestHandler;
-export {};
+export declare const traceMiddleware: ({
+  ignoreTraceRoutes,
+  traceHeaderKey,
+}?: HttpOptions) => RequestHandler;

package/dist/logger/src/middleware.js

@@ -1,76 +1,88 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.traceMiddleware = void 0;
-const span_1 = require("./span");
-const types_1 = require("./types");
-const utils_1 = require("./utils");
-const trace_1 = require("./trace");
+const span_1 = require('./span');
+const types_1 = require('./types');
+const utils_1 = require('./utils');
+const trace_1 = require('./trace');
 const getFullUrl = (req) => {
-    const url = req.originalUrl || req.url;
-    if (url?.startsWith('http://') || url?.startsWith('https://'))
-        return url;
-    // Check if we have a workflow URL configured (preferred method)
-    if (process.env.UNNBOUND_WORKFLOW_URL) {
-        // Use workflow URL as the base URL
-        return `${process.env.UNNBOUND_WORKFLOW_URL.replace(/\/$/, '')}${url}`;
-    }
-    // Fallback to constructing from request info for incoming requests
-    const protocol = req.protocol || (req.secure ? 'https' : 'http');
-    const host = req.get('host') || req.get('x-forwarded-host') || 'localhost';
-    return `${protocol}://${host}${url}`;
+  const url = req.originalUrl || req.url;
+  if (url?.startsWith('http://') || url?.startsWith('https://')) return url;
+  // Check if we have a workflow URL configured (preferred method)
+  if (process.env.UNNBOUND_WORKFLOW_URL) {
+    // Use workflow URL as the base URL
+    return `${process.env.UNNBOUND_WORKFLOW_URL.replace(/\/$/, '')}${url}`;
+  }
+  // Fallback to constructing from request info for incoming requests
+  const protocol = req.protocol || (req.secure ? 'https' : 'http');
+  const host = req.get('host') || req.get('x-forwarded-host') || 'localhost';
+  return `${protocol}://${host}${url}`;
 };
-const buildIncomingHttpPayload = (req, res) => ({
-    type: 'http',
-    http: {
-        url: getFullUrl(req),
-        method: req.method.toLowerCase(),
-        ip: (0, utils_1.normalizeIp)(req.ip),
-        incoming: true,
-        request: {
-            headers: req.headers,
-            body: (0, utils_1.safeJsonParse)(req.body),
-        },
-        response: res
-            ? {
-                headers: res.headers,
-                status: res.status,
-                body: (0, utils_1.safeJsonParse)(res.body),
-            }
-            : undefined,
+const buildIncomingHttpPayload = (req, res, body) => ({
+  type: 'http',
+  http: {
+    url: getFullUrl(req),
+    method: req.method.toLowerCase(),
+    ip: (0, utils_1.normalizeIp)(req.ip),
+    incoming: true,
+    request: {
+      headers: req.headers,
+      body: (0, utils_1.safeJsonParse)(req.body),
     },
+    response: res
+      ? {
+          headers: res?.headers,
+          status: res.statusCode,
+          body: (0, utils_1.safeJsonParse)(body),
+        }
+      : undefined,
+  },
 });
-const getNoopPayload = () => ({});
-const traceMiddleware = ({ ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes, traceHeaderKey = types_1.defaultTraceHeaderKey, getPayload = getNoopPayload, } = {
-    ignoreTraceRoutes: types_1.defaultIgnoreTraceRoutes,
-    traceHeaderKey: types_1.defaultTraceHeaderKey,
-    getPayload: getNoopPayload,
-}) => async (req, res, next) => {
-    if ((0, utils_1.shouldIgnorePath)(req.path, ignoreTraceRoutes))
-        return next();
+const traceMiddleware =
+  (
+    {
+      ignoreTraceRoutes = types_1.defaultIgnoreTraceRoutes,
+      traceHeaderKey = types_1.defaultTraceHeaderKey,
+    } = {
+      ignoreTraceRoutes: types_1.defaultIgnoreTraceRoutes,
+      traceHeaderKey: types_1.defaultTraceHeaderKey,
+    }
+  ) =>
+  async (req, res, next) => {
+    if ((0, utils_1.shouldIgnorePath)(req.path, ignoreTraceRoutes)) return next();
     const traceId = req.header(traceHeaderKey) || (0, trace_1.getTraceId)();
     res.setHeader(traceHeaderKey, traceId);
-    return await (0, trace_1.withTrace)(async () => {
-        return await (0, span_1.startSpan)('Incoming HTTP request', async () => {
+    return await (0, trace_1.withTrace)(
+      async () => {
+        return await (0, span_1.startSpan)(
+          'Incoming HTTP request',
+          async () => {
             return new Promise((resolve) => {
-                // Capture response body for logging
-                const send = res.send.bind(res);
-                res.send = (body) => {
-                    res.locals.body = body;
-                    return send(body);
-                };
-                res.on('finish', () => resolve());
-                return next();
+              // Capture response body for logging
+              const send = res.send.bind(res);
+              res.send = (body) => {
+                res.locals.body = body;
+                return send(body);
+              };
+              res.on('finish', () => resolve());
+              return next();
             });
-        }, (o) => {
-            const response = o
+          },
+          (o) => {
+            return buildIncomingHttpPayload(
+              req,
+              o
                 ? {
-                    status: res.statusCode,
+                    statusCode: res.statusCode,
                     headers: res.getHeaders(),
-                    body: res.locals.body,
-                }
-                : undefined;
-            return { ...buildIncomingHttpPayload(req, response), ...getPayload(req, response) };
-        });
-    }, { traceId });
-};
+                  }
+                : undefined,
+              res.locals.body
+            );
+          }
+        );
+      },
+      { traceId }
+    );
+  };
 exports.traceMiddleware = traceMiddleware;

package/dist/logger/src/span.d.ts

@@ -1,10 +1,12 @@
-type LogPayloadGetterOptions<T> = {
-    error: unknown;
-    result?: never;
-} | {
-    error?: never;
-    result: T;
-};
+type LogPayloadGetterOptions<T> =
+  | {
+      error: unknown;
+      result?: never;
+    }
+  | {
+      error?: never;
+      result: T;
+    };
 type LogPayloadGetter<T> = object | ((o?: LogPayloadGetterOptions<T>) => object);
 /**
  * Starts a span that tracks the duration of a callback
@@ -12,5 +14,9 @@ type LogPayloadGetter<T> = object | ((o?: LogPayloadGetterOptions<T>) => object)
  * @param callback - The async callback to execute
  * @returns The result of the callback
  */
-export declare const startSpan: <T>(spanName: string, callback: () => Promise<T>, getter?: LogPayloadGetter<T>) => Promise<T>;
+export declare const startSpan: <T>(
+  spanName: string,
+  callback: () => Promise<T>,
+  getter?: LogPayloadGetter<T>
+) => Promise<T>;
 export {};

package/dist/logger/src/span.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.startSpan = void 0;
-const uuid_1 = require("uuid");
-const storage_1 = require("./storage");
-const trace_1 = require("./trace");
-const logger_1 = require("./logger");
+const uuid_1 = require('uuid');
+const storage_1 = require('./storage');
+const trace_1 = require('./trace');
+const logger_1 = require('./logger');
 /**
  * Starts a span that tracks the duration of a callback
  * @param spanName - The span name to use for logging
@@ -12,30 +12,37 @@ const logger_1 = require("./logger");
  * @returns The result of the callback
  */
 const startSpan = async (spanName, callback, getter) => {
-    const spanId = (0, uuid_1.v4)();
-    const start = performance.now();
-    const previous = storage_1.storage.getStore();
-    return storage_1.storage.run({
-        ...previous,
-        traceId: previous?.traceId ?? (0, trace_1.getTraceId)(),
-        spanId: previous?.spanId ? `${spanId} ${previous?.spanId}` : spanId,
-    }, async () => {
-        logger_1.logger.info({ ...getLogPayload(getter) }, `${spanName} started.`);
-        try {
-            const result = await callback();
-            logger_1.logger.info({ ...getLogPayload(getter, { result }), duration: getDuration(start) }, `${spanName} completed.`);
-            return result;
-        }
-        catch (error) {
-            logger_1.logger.error({ ...getLogPayload(getter, { error }), err: error, duration: getDuration(start) }, `${spanName} failed.`);
-            throw error;
-        }
-    });
+  const spanId = (0, uuid_1.v4)();
+  const start = performance.now();
+  const previous = storage_1.storage.getStore();
+  return storage_1.storage.run(
+    {
+      ...previous,
+      traceId: previous?.traceId ?? (0, trace_1.getTraceId)(),
+      spanId: previous?.spanId ? `${spanId} ${previous?.spanId}` : spanId,
+    },
+    async () => {
+      logger_1.logger.info({ ...getLogPayload(getter) }, `${spanName} started.`);
+      try {
+        const result = await callback();
+        logger_1.logger.info(
+          { ...getLogPayload(getter, { result }), duration: getDuration(start) },
+          `${spanName} completed.`
+        );
+        return result;
+      } catch (error) {
+        logger_1.logger.error(
+          { ...getLogPayload(getter, { error }), err: error, duration: getDuration(start) },
+          `${spanName} failed.`
+        );
+        throw error;
+      }
+    }
+  );
 };
 exports.startSpan = startSpan;
 const getLogPayload = (getter, o) => {
-    if (typeof getter !== 'function')
-        return getter;
-    return getter(o);
+  if (typeof getter !== 'function') return getter;
+  return getter(o);
 };
 const getDuration = (start) => Math.round(performance.now() - start);

package/dist/logger/src/storage.d.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'async_hooks';
 export interface Context {
-    traceId?: string;
-    spanId?: string;
+  traceId?: string;
+  spanId?: string;
 }
 export declare const storage: AsyncLocalStorage<Context>;

package/dist/logger/src/storage.js

@@ -1,5 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.storage = void 0;
-const async_hooks_1 = require("async_hooks");
+const async_hooks_1 = require('async_hooks');
 exports.storage = new async_hooks_1.AsyncLocalStorage();

package/dist/logger/src/trace.d.ts

@@ -9,6 +9,12 @@ export declare const getTraceId: () => string;
  * @param extra - Extra context to add to the trace
  * @returns The result of the callback
  */
-export declare const withTrace: <T, E extends {
+export declare const withTrace: <
+  T,
+  E extends {
     traceId?: string;
-}>(callback: () => T, extra?: E) => T;
+  },
+>(
+  callback: () => T,
+  extra?: E
+) => T;

package/dist/logger/src/trace.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.withTrace = exports.getTraceId = void 0;
-const uuid_1 = require("uuid");
-const storage_1 = require("./storage");
+const uuid_1 = require('uuid');
+const storage_1 = require('./storage');
 /**
  * Generates a trace ID
  * @returns A trace ID
@@ -16,6 +16,13 @@ exports.getTraceId = getTraceId;
  * @returns The result of the callback
  */
 const withTrace = (callback, extra) => {
-    return storage_1.storage.run({ ...storage_1.storage.getStore(), ...extra, traceId: extra?.traceId ?? (0, exports.getTraceId)() }, callback);
+  return storage_1.storage.run(
+    {
+      ...storage_1.storage.getStore(),
+      ...extra,
+      traceId: extra?.traceId ?? (0, exports.getTraceId)(),
+    },
+    callback
+  );
 };
 exports.withTrace = withTrace;

package/dist/logger/src/types.d.ts

@@ -14,49 +14,67 @@ export type LogType = 'general' | 'http' | 'sftp';
  */
 export type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
 export interface Log<T extends LogType = 'general'> {
-    logId: string;
-    level: LogLevel;
-    message: string;
-    type: T;
-    traceId?: string;
-    spanId?: string;
-    serviceId?: string;
-    deploymentId?: string;
-    workflowId?: string;
-    http: T extends 'http' ? HttpPayload : never;
-    sftp: T extends 'sftp' ? SftpPayload : never;
-    duration?: number;
-    err?: unknown;
+  logId: string;
+  level: LogLevel;
+  message: string;
+  type: T;
+  traceId?: string;
+  spanId?: string;
+  serviceId?: string;
+  deploymentId?: string;
+  workflowId?: string;
+  http: T extends 'http' ? HttpPayload : never;
+  sftp: T extends 'sftp' ? SftpPayload : never;
+  duration?: number;
+  err?: unknown;
 }
 export interface HttpPayload {
-    url: string;
-    method: HttpMethod;
-    ip?: string;
-    request: {
-        headers: Record<string, string | string[]>;
-        body?: unknown;
-    };
-    response?: {
-        headers: Record<string, string | string[]>;
-        status: number;
-        body?: unknown;
-    };
+  url: string;
+  method: HttpMethod;
+  ip?: string;
+  request: {
+    headers: Record<string, string | string[]>;
+    body?: unknown;
+  };
+  response?: {
+    headers: Record<string, string | string[]>;
+    status: number;
+    body?: unknown;
+  };
 }
-export type SftpOperation = 'connect' | 'upload' | 'download' | 'list' | 'delete' | 'rename' | 'stat' | 'exists' | 'realPath' | 'get' | 'put' | 'cwd' | 'mkdir' | 'rmdir' | 'chmod' | 'append' | 'uploadDir' | 'downloadDir' | 'close';
+export type SftpOperation =
+  | 'connect'
+  | 'upload'
+  | 'download'
+  | 'list'
+  | 'delete'
+  | 'rename'
+  | 'stat'
+  | 'exists'
+  | 'realPath'
+  | 'get'
+  | 'put'
+  | 'cwd'
+  | 'mkdir'
+  | 'rmdir'
+  | 'chmod'
+  | 'append'
+  | 'uploadDir'
+  | 'downloadDir'
+  | 'close';
 export interface SftpPayload {
-    host: string;
-    operation: SftpOperation;
-    path?: string;
-    bytes?: number;
-    destinationPath?: string;
-    files?: string[];
-    content?: string;
-    exists?: string | false;
+  host: string;
+  operation: SftpOperation;
+  path?: string;
+  bytes?: number;
+  destinationPath?: string;
+  files?: string[];
+  content?: string;
+  exists?: string | false;
 }
-export interface HttpOptions<G extends Function> {
-    ignoreTraceRoutes?: string[];
-    traceHeaderKey?: string;
-    getPayload?: G;
+export interface HttpOptions {
+  ignoreTraceRoutes?: string[];
+  traceHeaderKey?: string;
 }
 export declare const defaultIgnoreTraceRoutes: string[];
-export declare const defaultTraceHeaderKey = "x-unnbound-trace-id";
+export declare const defaultTraceHeaderKey = 'x-unnbound-trace-id';

package/dist/logger/src/types.js

@@ -1,8 +1,8 @@
-"use strict";
+'use strict';
 /**
  * Type definitions for structured logging library
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.defaultTraceHeaderKey = exports.defaultIgnoreTraceRoutes = void 0;
 exports.defaultIgnoreTraceRoutes = ['/health', '/healthcheck'];
 exports.defaultTraceHeaderKey = 'x-unnbound-trace-id';