@aligent/microservice-util-lib 1.3.1 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aligent/microservice-util-lib",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "A set of utility functions for Aligent Microservices",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -15,7 +15,7 @@
     "@aws-sdk/client-ssm": "^3.922.0",
     "oauth-sign": "^0.9.0",
     "object-hash": "^3.0.0",
-    "openapi-fetch": "^0.15.0"
+    "openapi-fetch": "^0.17.0"
   },
   "author": "Aligent",
   "license": "MIT",

package/src/index.d.ts

@@ -3,9 +3,10 @@ import fetchSsmParams from './fetch-ssm-params/fetch-ssm-params';
 import getAwsIdFromArn from './get-aws-id-from-arn/get-aws-id-from-arn';
 import hasDefinedProperties from './has-properties-defined/has-properties-defined';
 import { ApiKey, Basic, OAuth10a, OAuth20, apiKeyAuthMiddleware, basicAuthMiddleware, oAuth10aAuthMiddleware, oAuth20AuthMiddleware } from './openapi-fetch-middlewares/authentications';
+import { LogLevel, Logger, logMiddleware } from './openapi-fetch-middlewares/log';
 import { RetryConfig as RetryMiddlewareConfig, retryMiddleware } from './openapi-fetch-middlewares/retry';
 import remap, { ObjectMap, Remap } from './remap/remap';
 import retryWrapper, { RetryConfig } from './retry-wrapper/retry-wrapper';
 import S3Dao from './s3/s3';
-export type { ApiKey, Basic, OAuth10a, OAuth20, ObjectMap, Remap, RetryConfig, RetryMiddlewareConfig, S3Dao, };
-export { apiKeyAuthMiddleware, basicAuthMiddleware, chunkBy, fetchSsmParams, getAwsIdFromArn, hasDefinedProperties, oAuth10aAuthMiddleware, oAuth20AuthMiddleware, remap, retryMiddleware, retryWrapper, };
+export type { ApiKey, Basic, LogLevel, Logger, OAuth10a, OAuth20, ObjectMap, Remap, RetryConfig, RetryMiddlewareConfig, S3Dao, };
+export { apiKeyAuthMiddleware, basicAuthMiddleware, chunkBy, fetchSsmParams, getAwsIdFromArn, hasDefinedProperties, logMiddleware, oAuth10aAuthMiddleware, oAuth20AuthMiddleware, remap, retryMiddleware, retryWrapper, };

package/src/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryWrapper = exports.retryMiddleware = exports.remap = exports.oAuth20AuthMiddleware = exports.oAuth10aAuthMiddleware = exports.hasDefinedProperties = exports.getAwsIdFromArn = exports.fetchSsmParams = exports.chunkBy = exports.basicAuthMiddleware = exports.apiKeyAuthMiddleware = void 0;
+exports.retryWrapper = exports.retryMiddleware = exports.remap = exports.oAuth20AuthMiddleware = exports.oAuth10aAuthMiddleware = exports.logMiddleware = exports.hasDefinedProperties = exports.getAwsIdFromArn = exports.fetchSsmParams = exports.chunkBy = exports.basicAuthMiddleware = exports.apiKeyAuthMiddleware = void 0;
 /* v8 ignore start */
 const chunk_by_1 = __importDefault(require("./chunk-by/chunk-by"));
 exports.chunkBy = chunk_by_1.default;
@@ -18,6 +18,8 @@ Object.defineProperty(exports, "apiKeyAuthMiddleware", { enumerable: true, get:
 Object.defineProperty(exports, "basicAuthMiddleware", { enumerable: true, get: function () { return authentications_1.basicAuthMiddleware; } });
 Object.defineProperty(exports, "oAuth10aAuthMiddleware", { enumerable: true, get: function () { return authentications_1.oAuth10aAuthMiddleware; } });
 Object.defineProperty(exports, "oAuth20AuthMiddleware", { enumerable: true, get: function () { return authentications_1.oAuth20AuthMiddleware; } });
+const log_1 = require("./openapi-fetch-middlewares/log");
+Object.defineProperty(exports, "logMiddleware", { enumerable: true, get: function () { return log_1.logMiddleware; } });
 const retry_1 = require("./openapi-fetch-middlewares/retry");
 Object.defineProperty(exports, "retryMiddleware", { enumerable: true, get: function () { return retry_1.retryMiddleware; } });
 const remap_1 = __importDefault(require("./remap/remap"));

package/src/openapi-fetch-middlewares/log.d.ts

@@ -0,0 +1,56 @@
+import type { Middleware } from 'openapi-fetch';
+/**
+ * Logger interface to support various logging implementations
+ * (console, winston, pino, bunyan, etc.)
+ */
+interface Logger {
+    info(message: string, ...args: unknown[]): void;
+    debug?(message: string, ...args: unknown[]): void;
+}
+type LogLevel = 'INFO' | 'DEBUG';
+/**
+ * Creates a logging middleware for openapi-fetch clients.
+ *
+ * This middleware logs HTTP requests and responses with Content-Type handling.
+ * It supports various logger implementations and configurable log levels (INFO or DEBUG).
+ *
+ * Features:
+ * - Automatic Content-Type detection and appropriate parsing
+ * - Support for JSON, text, XML, form data, and binary content
+ * - Configurable log levels (INFO/DEBUG)
+ * - Compatible with multiple logging libraries
+ *
+ * @param clientName - A descriptive name for the API client (used in log messages)
+ * @param logLevel - The logging level to use: 'INFO' (default) or 'DEBUG'
+ * @param logger - Logger instance implementing the Logger interface (defaults to console)
+ * @returns An openapi-fetch middleware that logs requests and responses
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with default console logger at INFO level
+ * import createClient from 'openapi-fetch';
+ *
+ * const client = createClient({ baseUrl: 'https://api.example.com' });
+ * client.use(logMiddleware('MyAPI'));
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using DEBUG level with console
+ * client.use(logMiddleware('MyAPI', 'DEBUG'));
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom logger implementation
+ * const customLogger = {
+ *   info: (msg, ...args) => console.log('[INFO]', msg, ...args),
+ *   debug: (msg, ...args) => console.log('[DEBUG]', msg, ...args)
+ * };
+ *
+ * client.use(logMiddleware('MyAPI', 'DEBUG', customLogger));
+ * ```
+ */
+declare function logMiddleware(clientName: string, logLevel?: LogLevel, logger?: Logger): Middleware;
+export { logMiddleware };
+export type { Logger, LogLevel };

package/src/openapi-fetch-middlewares/log.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logMiddleware = logMiddleware;
+/**
+ * Parse request/response body based on Content-Type header
+ */
+async function parseBody(source, contentType) {
+    const normalizedContentType = contentType ? contentType.toLowerCase() : 'application/json';
+    try {
+        // JSON content
+        if (normalizedContentType.includes('application/json')) {
+            return await source.clone().json();
+        }
+        // Text content
+        if (normalizedContentType.includes('text/') ||
+            normalizedContentType.includes('application/xml') ||
+            normalizedContentType.includes('application/x-www-form-urlencoded')) {
+            return await source.clone().text();
+        }
+        // Binary or multipart content - don't parse
+        if (normalizedContentType.includes('multipart/form-data') ||
+            normalizedContentType.includes('application/octet-stream') ||
+            normalizedContentType.includes('image/') ||
+            normalizedContentType.includes('video/') ||
+            normalizedContentType.includes('audio/')) {
+            return `[Binary content: ${contentType}]`;
+        }
+        // Unknown content type, try JSON as default
+        return await source.clone().json();
+    }
+    catch (error) {
+        return `[Unable to parse ${contentType} body: ${error instanceof Error ? error.message : 'Unknown error'}]`;
+    }
+}
+/**
+ * Creates a logging middleware for openapi-fetch clients.
+ *
+ * This middleware logs HTTP requests and responses with Content-Type handling.
+ * It supports various logger implementations and configurable log levels (INFO or DEBUG).
+ *
+ * Features:
+ * - Automatic Content-Type detection and appropriate parsing
+ * - Support for JSON, text, XML, form data, and binary content
+ * - Configurable log levels (INFO/DEBUG)
+ * - Compatible with multiple logging libraries
+ *
+ * @param clientName - A descriptive name for the API client (used in log messages)
+ * @param logLevel - The logging level to use: 'INFO' (default) or 'DEBUG'
+ * @param logger - Logger instance implementing the Logger interface (defaults to console)
+ * @returns An openapi-fetch middleware that logs requests and responses
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with default console logger at INFO level
+ * import createClient from 'openapi-fetch';
+ *
+ * const client = createClient({ baseUrl: 'https://api.example.com' });
+ * client.use(logMiddleware('MyAPI'));
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using DEBUG level with console
+ * client.use(logMiddleware('MyAPI', 'DEBUG'));
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom logger implementation
+ * const customLogger = {
+ *   info: (msg, ...args) => console.log('[INFO]', msg, ...args),
+ *   debug: (msg, ...args) => console.log('[DEBUG]', msg, ...args)
+ * };
+ *
+ * client.use(logMiddleware('MyAPI', 'DEBUG', customLogger));
+ * ```
+ */
+function logMiddleware(clientName, logLevel = 'INFO', logger = console) {
+    const log = (message, ...args) => {
+        if (logLevel === 'DEBUG' && logger.debug) {
+            logger.debug(message, ...args);
+            return;
+        }
+        logger.info(message, ...args);
+    };
+    return {
+        async onRequest({ options, params, request }) {
+            const contentType = request.headers.get('Content-Type');
+            log(`${request.method} request to ${clientName}`, {
+                method: request.method,
+                baseUrl: options.baseUrl,
+                url: request.url,
+                params: params,
+                body: await parseBody(request, contentType),
+            });
+        },
+        async onResponse({ response }) {
+            const contentType = response.headers.get('Content-Type');
+            log(`Response from ${clientName}`, {
+                status: response.status,
+                body: await parseBody(response, contentType),
+            });
+        },
+    };
+}

package/src/openapi-fetch-middlewares/oauth10a/oauth10a.js

@@ -140,8 +140,14 @@ function shouldGenerateBodyHash(body, method, includeBodyHash) {
 async function generateOauthParams(request, options, params, config) {
     const { algorithm, includeBodyHash = 'auto', realm, callback, verifier } = config;
     const { consumerKey, consumerSecret, token, tokenSecret } = await config.credentials();
-    const method = (request.method || 'GET').toUpperCase();
-    const url = combineUrlAndPathParams(request.url, params.path);
+    // Due to the way that openapi-fetch & fetch API are implemented in NodeJS (undici),
+    // each request only can be used ONCE. We have to clone the request like this to extract information
+    // Otherwise, undici will not be able to create & send the request.
+    const clonedRequest = request.clone();
+    const method = (clonedRequest.method || 'GET').toUpperCase();
+    const url = combineUrlAndPathParams(clonedRequest.url, params.path);
+    const contentType = clonedRequest.headers.get('Content-Type');
+    const body = await clonedRequest.text();
     const oauthParams = {
         oauth_consumer_key: consumerKey,
         oauth_nonce: crypto_1.default.randomUUID(),
@@ -165,22 +171,18 @@ async function generateOauthParams(request, options, params, config) {
     if (params.query) {
         addParamsToSign(paramsToSign, params.query);
     }
-    const body = await request.text();
     // If user submit a form, then include form parameters in the
     // signature as parameters rather than the body hash
-    if (request.headers.get('Content-Type') === 'application/x-www-form-urlencoded') {
+    if (contentType === 'application/x-www-form-urlencoded') {
         addParamsToSign(paramsToSign, new URLSearchParams(body));
-        console.log(JSON.stringify(paramsToSign));
     }
-    else {
-        if (shouldGenerateBodyHash(body, method, includeBodyHash)) {
-            const bodyHash = crypto_1.default
-                .createHash(algorithm === 'HMAC-SHA1' ? 'sha1' : 'sha256')
-                .update(Buffer.from(body))
-                .digest('base64');
-            oauthParams.oauth_body_hash = bodyHash;
-            addParamToSign(paramsToSign, 'oauth_body_hash', bodyHash);
-        }
+    else if (shouldGenerateBodyHash(body, method, includeBodyHash)) {
+        const bodyHash = crypto_1.default
+            .createHash(algorithm === 'HMAC-SHA1' ? 'sha1' : 'sha256')
+            .update(Buffer.from(body))
+            .digest('base64');
+        oauthParams.oauth_body_hash = bodyHash;
+        addParamToSign(paramsToSign, 'oauth_body_hash', bodyHash);
     }
     const oauthUrl = getOAuthUrl(options.baseUrl, url);
     oauthParams.oauth_signature = (0, oauth_sign_1.sign)(algorithm, method, oauthUrl, paramsToSign, consumerSecret, tokenSecret);

package/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.9.3"}