@dvsa/appdev-api-common 0.9.3-canary.0 → 0.10.1

package/auth/client-credentials.js

@@ -54,13 +54,20 @@ class ClientCredentials {
         const response = await fetch(this.tokenUrl, {
             method: "POST",
             headers: { "Content-Type": "application/x-www-form-urlencoded" },
-            body: (0, node_querystring_1.stringify)({
-                grant_type: ClientCredentials.grantType,
-                client_id: this.clientId,
-                client_secret: this.clientSecret,
-                scope: this.scope,
-                resource: this.resource,
-            }),
+            body: this.resource
+                ? (0, node_querystring_1.stringify)({
+                    grant_type: ClientCredentials.grantType,
+                    client_id: this.clientId,
+                    client_secret: this.clientSecret,
+                    scope: this.scope,
+                    resource: this.resource,
+                })
+                : (0, node_querystring_1.stringify)({
+                    grant_type: ClientCredentials.grantType,
+                    client_id: this.clientId,
+                    client_secret: this.clientSecret,
+                    scope: this.scope,
+                }),
         });
         if (!response.ok) {
             console.error("Error fetching client credentials", response);

package/package.json

@@ -1,11 +1,7 @@
 {
 	"name": "@dvsa/appdev-api-common",
-	"version": "0.9.3-canary.0",
-	"keywords": [
-		"dvsa",
-		"nodejs",
-		"typescript"
-	],
+	"version": "0.10.1",
+	"keywords": ["dvsa", "nodejs", "typescript"],
 	"author": "DVSA",
 	"description": "Utils library for common API functionality",
 	"publishConfig": {

package/utils/decode-payload-middleware.d.ts

@@ -1,2 +1,9 @@
-import type { NextFunction, Response, Request } from 'express';
+import type { NextFunction, Request, Response } from "express";
+/**
+ * Middleware to decode base64+gzip encoded request payloads and turn them into their JSON equivalent
+ * @param {Request} request - Express request object
+ * @param {Response} response - Express response object
+ * @param {NextFunction} next - Next function to pass control to the next middleware
+ * @constructor
+ */
 export declare const DecodeBase64GzipPayload: (request: Request, response: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/utils/decode-payload-middleware.js

@@ -1,17 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DecodeBase64GzipPayload = void 0;
-const compression_1 = require("./compression");
 const http_status_codes_1 = require("../api/http-status-codes");
+const compression_1 = require("./compression");
+/**
+ * Middleware to decode base64+gzip encoded request payloads and turn them into their JSON equivalent
+ * @param {Request} request - Express request object
+ * @param {Response} response - Express response object
+ * @param {NextFunction} next - Next function to pass control to the next middleware
+ * @constructor
+ */
 const DecodeBase64GzipPayload = (request, response, next) => {
-    const compressionHeaderValue = 'base64+gzip';
+    const compressionHeaderValue = "base64+gzip";
     try {
-        if (typeof request.body === 'string' && request.header('X-Payload-Encoding') === compressionHeaderValue) {
+        if (typeof request.body === "string" &&
+            request.header("X-Payload-Encoding") === compressionHeaderValue) {
             request.body = compression_1.DataCompression.decompress(request.body);
         }
     }
     catch (err) {
-        return response.status(http_status_codes_1.HttpStatus.BAD_REQUEST).send({ message: 'Failed to decode payload' });
+        return response.status(http_status_codes_1.HttpStatus.BAD_REQUEST).send({
+            error: "Bad request",
+            message: err instanceof Error ? err.message : JSON.stringify(err),
+        });
     }
     next();
 };

package/utils/encode-payload-interceptor.d.ts

@@ -1,6 +1,13 @@
-import type { Request, Response } from 'express';
-import type { APIGatewayProxyResult } from 'aws-lambda';
-import type { Logger } from '@aws-lambda-powertools/logger';
+import type { Logger } from "@aws-lambda-powertools/logger";
+import type { APIGatewayProxyResult } from "aws-lambda";
+import type { Request, Response } from "express";
+/**
+ * Interceptor to encode the response payload if requested by the client
+ * @param {Request, Response} request, response - Express request & response object
+ * @param {Partial<APIGatewayProxyResult>} content - API Gateway Proxy Result content
+ * @param {Logger} logger - Logger instance
+ * @constructor
+ */
 export declare const EncodePayloadInterceptor: ({ response, request }: {
     response: Response;
     request: Request;

package/utils/encode-payload-interceptor.js

@@ -3,8 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EncodePayloadInterceptor = void 0;
 const http_status_codes_1 = require("../api/http-status-codes");
 const compression_1 = require("./compression");
+/**
+ * Interceptor to encode the response payload if requested by the client
+ * @param {Request, Response} request, response - Express request & response object
+ * @param {Partial<APIGatewayProxyResult>} content - API Gateway Proxy Result content
+ * @param {Logger} logger - Logger instance
+ * @constructor
+ */
 const EncodePayloadInterceptor = ({ response, request }, content, logger) => {
-    const compressionHeaderValue = 'base64+gzip';
+    const compressionHeaderValue = "base64+gzip";
     for (const [header, value] of Object.entries(content?.headers || {})) {
         response.setHeader(header, value);
     }
@@ -15,30 +22,30 @@ const EncodePayloadInterceptor = ({ response, request }, content, logger) => {
     if (!content.body) {
         return response;
     }
-    const didRequestCompressed = request?.headers?.['x-accept-encoding'] === compressionHeaderValue;
+    const didRequestCompressed = request?.headers?.["x-accept-encoding"] === compressionHeaderValue;
     const shouldCompress = didRequestCompressed && content.statusCode === http_status_codes_1.HttpStatus.OK;
     // Parse the body if it's a string
-    const bodyData = typeof content.body === 'string' ? JSON.parse(content.body) : content.body;
+    const bodyData = typeof content.body === "string" ? JSON.parse(content.body) : content.body;
     if (shouldCompress) {
-        logger.debug('Compressing response data');
+        logger.debug("Compressing response data");
         try {
             const compressedData = compression_1.DataCompression.compress(bodyData);
             // Check if compressed data is actually smaller
-            const originalSize = Buffer.byteLength(JSON.stringify(bodyData), 'utf8');
-            const compressedSize = Buffer.byteLength(JSON.stringify(compressedData), 'utf8');
+            const originalSize = Buffer.byteLength(JSON.stringify(bodyData), "utf8");
+            const compressedSize = Buffer.byteLength(JSON.stringify(compressedData), "utf8");
             if (compressedSize >= originalSize) {
-                logger.debug('Compression not beneficial, using original data');
+                logger.debug("Compression not beneficial, using original data");
                 response.json(bodyData);
             }
             else {
                 // Set the content encoding headers
-                response.setHeader('Access-Control-Expose-Headers', 'content-encoding');
-                response.setHeader('content-encoding', compressionHeaderValue);
+                response.setHeader("Access-Control-Expose-Headers", "content-encoding");
+                response.setHeader("content-encoding", compressionHeaderValue);
                 response.json(compressedData);
             }
         }
         catch (err) {
-            logger.error('Error compressing response data', { err });
+            logger.error("Error compressing response data", { err });
             response.json(bodyData);
         }
     }