@spytecgps/lambda-utils 3.0.5 → 3.0.6-rc.0

package/dist/middleware/contextualLogger.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const AMAZON_TRACE_ID = '_X_AMZN_TRACE_ID';
+const CORRELATION_HEADER = 'x-correlation-';
+const CORRELATION_ID = `${CORRELATION_HEADER}id`;
+const CORRELATION_TRACE_ID = `${CORRELATION_HEADER}trace-id`;
+const contextualLogger = ({ logger }) => {
+    const before = async ({ event, context }) => {
+        const ctx = {
+            awsRequestId: context?.awsRequestId,
+        };
+        // capture api gateway request ID
+        const apiRequestId = event?.requestContext?.requestId;
+        if (apiRequestId) {
+            ctx.apiRequestId = apiRequestId;
+        }
+        // capture any correlation headers sent from upstream callers
+        if (event.headers) {
+            Object.keys(event.headers).forEach((header) => {
+                if (header.toLowerCase().startsWith(CORRELATION_HEADER)) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    ctx[header] = event.headers[header];
+                }
+            });
+        }
+        // capture the xray trace id if its enabled
+        if (process.env[AMAZON_TRACE_ID]) {
+            ctx[CORRELATION_TRACE_ID] = process.env[AMAZON_TRACE_ID];
+        }
+        // set the correlation id if not already set by upstream callers
+        /* istanbul ignore next */
+        if (!ctx[CORRELATION_ID]) {
+            ctx[CORRELATION_ID] = context.awsRequestId;
+        }
+        logger.setHapnContext(ctx);
+    };
+    return {
+        before,
+    };
+};
+
+exports.contextualLogger = contextualLogger;

package/dist/middleware/http/response.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const baseHeaders = {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Credentials': true,
+};
+const buildResponseBody = (statusCode, message, data) => {
+    return {
+        success: statusCode < 400,
+        message,
+        result: typeof data !== 'undefined' ? data : undefined,
+    };
+};
+const buildProxyResult = ({ statusCode = 200, message = 'ok', data, headers = {}, multiValueHeaders = {}, rawResult = false, stringifyBody = true, }) => {
+    const resp = rawResult ? data : buildResponseBody(statusCode, message, data);
+    const body = stringifyBody ? resp && JSON.stringify(resp) : data;
+    return {
+        headers: { ...baseHeaders, ...headers },
+        multiValueHeaders,
+        statusCode,
+        body,
+    };
+};
+
+exports.buildProxyResult = buildProxyResult;
+exports.buildResponseBody = buildResponseBody;

package/dist/middleware/index.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var core = require('@middy/core');
+var httpErrorHandler = require('@middy/http-error-handler');
+var httpResponseSerializer = require('@middy/http-response-serializer');
+var sqsJsonBodyParser = require('@middy/sqs-json-body-parser');
+var contextualLogger = require('./contextualLogger.js');
+var ioLogger = require('./ioLogger.js');
+var normalizer = require('./normalizer.js');
+var offlineAuthorizer = require('./offlineAuthorizer.js');
+var responseWrapper = require('./responseWrapper.js');
+var warmup = require('./warmup.js');
+
+// Function that returns base middlewares with required logger
+const getBaseMiddlewares = ({ logger }) => [
+    warmup.warmupMiddleware(),
+    contextualLogger.contextualLogger({ logger }),
+    ioLogger.ioLogger({ logger }),
+];
+// Function that returns API Gateway middlewares with required logger
+const getApiGatewayMiddlewares = ({ logger, offlineAuthEnabled }) => [
+    httpResponseSerializer({
+        serializers: [
+            {
+                regex: /^application\/xml$/,
+                serializer: ({ body }) => `<message>${body}</message>`,
+            },
+            {
+                regex: /^application\/json$/,
+                serializer: ({ body }) => JSON.stringify(body),
+            },
+            {
+                regex: /^text\/plain$/,
+                serializer: ({ body }) => body,
+            },
+        ],
+        default: 'application/json',
+    }),
+    responseWrapper.responseWrapper({ logger }),
+    offlineAuthorizer.offlineAuth({ logger, enabled: offlineAuthEnabled }),
+    normalizer.normalizerMiddleware(),
+];
+
+exports.middy = core;
+exports.httpErrorHandler = httpErrorHandler;
+exports.httpResponseSerializer = httpResponseSerializer;
+exports.sqsJsonBodyParser = sqsJsonBodyParser;
+exports.contextualLogger = contextualLogger.contextualLogger;
+exports.ioLogger = ioLogger.ioLogger;
+exports.offlineAuth = offlineAuthorizer.offlineAuth;
+exports.responseWrapper = responseWrapper.responseWrapper;
+exports.warmupMiddleware = warmup.warmupMiddleware;
+exports.getApiGatewayMiddlewares = getApiGatewayMiddlewares;
+exports.getBaseMiddlewares = getBaseMiddlewares;

package/dist/middleware/ioLogger.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var inputOutputLogger = require('@middy/input-output-logger');
+var index = require('../config/index.js');
+
+const ioLogger = ({ logger }) => inputOutputLogger({
+    omitPaths: [
+        'event.multiValueHeaders',
+        'event.multiValueQueryStringParameters',
+        'event.resource',
+        'event.httpMethod',
+        'event.headers',
+        'event.stageVariables',
+        'event.requestContext.resourceId',
+        'event.requestContext.resourcePath',
+        'event.requestContext.httpMethod',
+        'event.requestContext.extendedRequestId',
+        'event.requestContext.requestTime',
+        'event.requestContext.path',
+        'event.requestContext.accountId',
+        'event.requestContext.protocol',
+        'event.requestContext.stage',
+        'event.requestContext.domainPrefix',
+        'event.requestContext.requestTimeEpoch',
+        'event.requestContext.apiId',
+        'event.requestContext.domainName',
+        'event.requestContext.identity',
+        'event.isBase64Encoded',
+        'event.body',
+        'response.body',
+        'response.headers',
+    ],
+    logger: (req) => {
+        if (index.isLocal() || index.isTest()) {
+            return;
+        }
+        const message = req?.event ? 'event' : 'response';
+        logger.info(req.event ?? req.response, message);
+    },
+});
+
+exports.ioLogger = ioLogger;

package/dist/middleware/normalizer.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const normalizerMiddleware = () => {
+    return {
+        before: async (request) => {
+            const event = request.event;
+            event.queryStringParameters = event.queryStringParameters || {};
+            event.pathParameters = event.pathParameters || {};
+        },
+    };
+};
+
+exports.normalizerMiddleware = normalizerMiddleware;

package/dist/middleware/offlineAuthorizer.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var clientLambda = require('@aws-sdk/client-lambda');
+var index = require('../config/index.js');
+
+const defaultAuthFunctionName = process.env.STAGE === 'dev'
+    ? 'spytec-web-api-auth-dev-AuthorizerFunctionV4'
+    : 'spytec-web-api-auth-prod-AuthorizerFunctionV4';
+const offlineAuth = ({ authFunctionName = defaultAuthFunctionName, enabled = index.isOffline(), logger, }) => {
+    const lambdaClient = new clientLambda.LambdaClient({ region: process.env.AWS_REGION });
+    return {
+        before: async (request) => {
+            if (!enabled)
+                return;
+            const { event } = request;
+            // Extract Bearer token from the Authorization header
+            const authHeader = event.headers?.Authorization || event.headers?.authorization;
+            if (!authHeader || !authHeader.startsWith('Bearer ')) {
+                // throw new Error('Authorization header is missing or invalid')
+                // if we can't extract the token, this is is a public route, ignore it
+                logger.warn('Authorization header is missing or invalid, skipping fake offline authorization');
+                return;
+            }
+            const token = authHeader.slice(7); // Remove 'Bearer ' prefix
+            // Prepare payload for the auth function
+            const payload = {
+                authorizationToken: token,
+            };
+            // Invoke the auth function manually
+            const command = new clientLambda.InvokeCommand({
+                FunctionName: authFunctionName,
+                Payload: Buffer.from(JSON.stringify(payload)),
+            });
+            try {
+                const response = await lambdaClient.send(command);
+                const responsePayload = JSON.parse(Buffer.from(response.Payload ?? '').toString());
+                if (responsePayload.errorMessage) {
+                    throw new Error(responsePayload.errorMessage);
+                }
+                event.requestContext.authorizer = responsePayload.context;
+            }
+            catch (error) {
+                logger.error(error, 'Error invoking auth function');
+                throw new Error('Authorization failed');
+            }
+        },
+    };
+};
+
+exports.offlineAuth = offlineAuth;

package/dist/middleware/responseWrapper.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var response = require('./http/response.js');
+
+const responseWrapper = ({ logger }) => {
+    const responseWrapperMiddlewareAfter = (req) => {
+        req.response = response.buildProxyResult(req.response);
+    };
+    const responseWrapperMiddlewareError = (req) => {
+        const statusCode = req.error?.code ?? 500;
+        const errorMessage = req.error?.message || 'Error';
+        const loggerMethod = statusCode >= 500 ? 'error' : 'info';
+        logger[loggerMethod](req.error, 'Request failed');
+        req.response = response.buildProxyResult({
+            statusCode,
+            message: errorMessage,
+        });
+    };
+    return {
+        after: responseWrapperMiddlewareAfter,
+        onError: responseWrapperMiddlewareError,
+    };
+};
+
+exports.responseWrapper = responseWrapper;

package/dist/middleware/validation.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var BadRequestError = require('../errors/BadRequestError.js');
+
+const validator = ({ schema, allowUnknown = true, logger }) => {
+    const validatorMiddlewareBefore = (request) => {
+        const { error, value } = schema.validate(request.event, {
+            allowUnknown,
+            errors: {
+                label: 'key',
+                wrap: {
+                    label: false,
+                },
+            },
+        });
+        if (error) {
+            logger.warn(error, 'Validation error');
+            throw error.isJoi ? new BadRequestError.default(error.message) : error;
+        }
+        request.event = value;
+    };
+    return {
+        before: validatorMiddlewareBefore,
+    };
+};
+
+exports.validator = validator;

package/dist/middleware/warmup.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const defaults = {
+    isWarmingUp: (event) => event.source === 'serverless-plugin-warmup',
+};
+const warmupMiddleware = (opt = {}) => {
+    const options = { ...defaults, ...opt };
+    const warmupMiddlewareBefore = (request) => {
+        if (options.isWarmingUp(request.event)) {
+            return 'warmup';
+        }
+    };
+    return {
+        before: warmupMiddlewareBefore,
+    };
+};
+
+exports.warmupMiddleware = warmupMiddleware;

package/dist/utils/cache.js

@@ -0,0 +1,59 @@
+'use strict';
+
+class LambdaCache {
+    collectionName;
+    /**
+     * @param {String} collectionName (not required) - The collection key used to store the cache values.
+     *                                If not provide default collection name uses :
+     *                                ${process.env.AWS_LAMBDA_FUNCTION_NAME}-${process.env.AWS_LAMBDA_FUNCTION_VERSION}
+     * */
+    constructor(collectionName) {
+        this.collectionName =
+            collectionName ?? `${process.env.AWS_LAMBDA_FUNCTION_NAME}-${process.env.AWS_LAMBDA_FUNCTION_VERSION}`;
+        if (!global['CACHE_STORAGE']) {
+            global['CACHE_STORAGE'] = {};
+        }
+        if (!global['CACHE_STORAGE'][this.collectionName]) {
+            global['CACHE_STORAGE'][this.collectionName] = new Map();
+        }
+    }
+    /**
+     * @param {String} key (required) - cache key
+     * @param {Object} value (required) - cache value
+     * @param {Number} expire (required) - cache expiration time (seconds)
+     * */
+    set(key, value, ttl) {
+        const expire = 1000 * ttl + Date.now();
+        global['CACHE_STORAGE'][this.collectionName].set(key, { value, expire });
+    }
+    /**
+     * @param {String} key (required) - cache key to get
+     * */
+    get(key) {
+        if (!key) {
+            throw new Error('key is required!');
+        }
+        const record = global['CACHE_STORAGE'][this.collectionName].get(key);
+        if (!record) {
+            return null;
+        }
+        if (!record.expire || record.expire > Date.now()) {
+            return record.value;
+        }
+        else {
+            return this.remove(key);
+        }
+    }
+    /**
+     * @param {String} key (required) - cache key to remove
+     * */
+    remove(key) {
+        const record = global['CACHE_STORAGE'][this.collectionName].get(key);
+        if (!record) {
+            return;
+        }
+        global['CACHE_STORAGE'][this.collectionName].delete(key);
+    }
+}
+
+exports.LambdaCache = LambdaCache;

package/dist/utils/cacheWrapper.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const promiseWithCache = async (promise, cacheInstance, cacheKey, ttl) => {
+    let instance = cacheInstance.get(cacheKey);
+    if (!instance) {
+        instance = await promise();
+        cacheInstance.set(cacheKey, instance, ttl);
+    }
+    return instance;
+};
+
+exports.promiseWithCache = promiseWithCache;

package/dist/utils/timeOut.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const promiseWithTimeout = (promise, ms, timeoutError = new Error('Promise timed out')) => {
+    // create a promise that rejects in milliseconds
+    const timeout = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(timeoutError);
+        }, ms);
+    });
+    // returns a race between timeout and the passed promise
+    return Promise.race([promise, timeout]);
+    //Adding comment to test
+};
+
+exports.promiseWithTimeout = promiseWithTimeout;

package/dist/validation/custom.js

@@ -0,0 +1,165 @@
+'use strict';
+
+var dayjs = require('dayjs');
+var timezone = require('dayjs/plugin/timezone');
+var utc = require('dayjs/plugin/utc');
+var Joi = require('joi');
+var qs = require('qs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var Joi__namespace = /*#__PURE__*/_interopNamespaceDefault(Joi);
+var qs__namespace = /*#__PURE__*/_interopNamespaceDefault(qs);
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+const json = Joi__namespace.extend((joi) => {
+    return {
+        type: 'object',
+        base: joi.object(),
+        messages: {
+            'json.valid': 'must be valid JSON',
+        },
+        coerce(value) {
+            try {
+                return { value: JSON.parse(value) };
+            }
+            catch (err) {
+                return null;
+            }
+        },
+        validate(value, helpers) {
+            if (!value) {
+                return { value, errors: helpers.error('json.valid') };
+            }
+            return { value };
+        },
+    };
+});
+const urlEncoded = Joi__namespace.extend((joi) => {
+    return {
+        type: 'object',
+        base: joi.object(),
+        coerce(value) {
+            return { value: qs__namespace.parse(value) };
+        },
+    };
+});
+const imeiSchema = Joi__namespace.string()
+    .regex(/^\d{15,16}$/)
+    .message('Invalid IMEI');
+const iccidSchema = Joi__namespace.string()
+    .regex(/^[0-9A-Za-z]{18,22}$/)
+    .message('Invalid ICCID');
+const SpytecJoi = Joi__namespace.extend((joi) => ({
+    type: 'imei',
+    messages: 'Invalid IMEI',
+    base: joi.string().regex(/^\d{15,16}$/),
+}), (joi) => ({
+    type: 'iccid',
+    messages: 'Invalid ICCID',
+    base: joi.string().regex(/^[0-9A-Za-z]{18,22}$/),
+}), (joi) => ({
+    type: 'urlEncodedObject',
+    base: joi.object(),
+    coerce(value) {
+        return { value: qs__namespace.parse(value) };
+    },
+}), (joi) => ({
+    type: 'jsonObject',
+    base: joi.object(),
+    coerce(value) {
+        try {
+            return { value: JSON.parse(value) };
+        }
+        catch (err) {
+            return null;
+        }
+    },
+    validate(value, helpers) {
+        if (!value) {
+            return { value, errors: helpers.error('json.valid') };
+        }
+        return { value };
+    },
+}), (joi) => ({
+    type: 'delimitedArray',
+    base: joi.array().default([]),
+    coerce: (value) => ({
+        value: value.split ? value.split(',') : value,
+    }),
+}), (joi) => ({
+    type: 'queryStringParameters',
+    messages: 'Missing query parameters',
+    base: joi.object().required(),
+}), (joi) => ({
+    type: 'date',
+    base: joi.date(),
+    prepare(value, helpers) {
+        try {
+            const dayjsDate = dayjs.tz(value, 'UTC');
+            if (dayjsDate.isValid()) {
+                return { value: dayjsDate.toDate() };
+            }
+        }
+        catch (error) {
+            return helpers.error('any.invalid');
+        }
+    },
+}), (joi) => ({
+    type: 'jsonArray',
+    base: joi.array(),
+    coerce(value) {
+        try {
+            return { value: JSON.parse(value) };
+        }
+        catch (err) {
+            return { value: null };
+        }
+    },
+    validate(value, helpers) {
+        if (!Array.isArray(value)) {
+            return { value, errors: helpers.error('jsonArray.schema') };
+        }
+        return { value };
+    },
+}), (joi) => ({
+    type: 'base64ThenUriEncodedObject',
+    base: joi.object(),
+    coerce(value) {
+        try {
+            const decodedValue = decodeURIComponent(Buffer.from(value, 'base64').toString());
+            return { value: JSON.parse(decodedValue) };
+        }
+        catch (err) {
+            return null;
+        }
+    },
+    validate(value, helpers) {
+        if (!value) {
+            return { value, errors: helpers.error('json.valid') };
+        }
+        return { value };
+    },
+}));
+
+exports.SpytecJoi = SpytecJoi;
+exports.iccidSchema = iccidSchema;
+exports.imeiSchema = imeiSchema;
+exports.json = json;
+exports.urlEncoded = urlEncoded;

package/dist/validation/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var custom = require('./custom.js');
+var requestContext = require('./requestContext.js');
+
+const defaultApiSchema = custom.SpytecJoi.object({
+    requestContext: requestContext.getRequestContextValidator(),
+});
+
+exports.SpytecJoi = custom.SpytecJoi;
+exports.iccidSchema = custom.iccidSchema;
+exports.imeiSchema = custom.imeiSchema;
+exports.json = custom.json;
+exports.urlEncoded = custom.urlEncoded;
+exports.getAuthorizerValidator = requestContext.getAuthorizerValidator;
+exports.getAuthorizerValidatorV4 = requestContext.getAuthorizerValidatorV4;
+exports.getRequestContextValidator = requestContext.getRequestContextValidator;
+exports.getRequestContextValidatorV4 = requestContext.getRequestContextValidatorV4;
+exports.requestContextValidator = requestContext.requestContextValidator;
+exports.defaultApiSchema = defaultApiSchema;

package/dist/validation/requestContext.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var Joi = require('joi');
+var custom = require('./custom.js');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var Joi__namespace = /*#__PURE__*/_interopNamespaceDefault(Joi);
+
+const getAuthorizerValidator = (params = {}) => {
+    return Joi__namespace.object({
+        clientId: Joi__namespace.number().greater(0).required(),
+        userId: Joi__namespace.string().guid( /*{ version: 'uuidv4' }*/).required(),
+        resources: custom.json.object({}),
+        scope: Joi__namespace.string().optional(),
+        //       .error(() => new UnauthorizedError(`missing scope ${scope}`))
+        type: Joi__namespace.string().optional(),
+        //       .error(() => new UnauthorizedError(`missing user type ${type}`))
+        enterprise: Joi__namespace.boolean().default(false),
+        maintenanceModule: Joi__namespace.boolean().default(false),
+        billingMethod: Joi__namespace.string().optional(),
+        customerSegment: Joi__namespace.string().optional(),
+        securityGroupTagId: Joi__namespace.number().optional().allow(null),
+        securityRole: Joi__namespace.string().optional().allow(null),
+        ...params,
+    });
+};
+const getAuthorizerValidatorV4 = (params = {}) => {
+    return Joi__namespace.object({
+        clientId: Joi__namespace.number().greater(0).required(),
+        userId: Joi__namespace.string().guid( /*{ version: 'uuidv4' }*/).required(),
+        scope: Joi__namespace.string().optional(),
+        type: Joi__namespace.string().optional(),
+        ...params,
+    });
+};
+/**
+ * @deprecated
+ */
+const requestContextValidator = Joi__namespace.object({
+    authorizer: getAuthorizerValidator(),
+});
+const getRequestContextValidator = (params = {}) => {
+    return Joi__namespace.object({
+        authorizer: getAuthorizerValidator(params),
+    });
+};
+const getRequestContextValidatorV4 = (params = {}) => {
+    return Joi__namespace.object({
+        authorizer: getAuthorizerValidatorV4(params),
+    });
+};
+
+exports.getAuthorizerValidator = getAuthorizerValidator;
+exports.getAuthorizerValidatorV4 = getAuthorizerValidatorV4;
+exports.getRequestContextValidator = getRequestContextValidator;
+exports.getRequestContextValidatorV4 = getRequestContextValidatorV4;
+exports.requestContextValidator = requestContextValidator;