@spytecgps/lambda-utils 2.3.10 → 2.3.12

package/dist/index.js

@@ -1 +1,731 @@
-"use strict";var e=require("@spytecgps/sdk-logger"),r=require("dayjs"),t=require("dayjs/plugin/timezone"),o=require("dayjs/plugin/utc"),s=require("joi"),a=require("@middy/core"),n=require("@middy/http-error-handler"),i=require("@middy/http-response-serializer"),l=require("@middy/sqs-json-body-parser"),d=require("deepmerge"),c=require("@middy/input-output-logger"),u=require("@aws-sdk/client-lambda");function p(e){var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var o=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,o.get?o:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}var g=p(s),m=require("./stringify"),v=require("./parse"),h=require("./formats");module.exports={formats:h,parse:v,stringify:m},r.extend(o),r.extend(t);const y=g.extend((e=>({type:"object",base:e.object(),messages:{"json.valid":"must be valid JSON"},coerce(e){try{return{value:JSON.parse(e)}}catch(e){return null}},validate:(e,r)=>e?{value:e}:{value:e,errors:r.error("json.valid")}}))),x=g.extend((e=>({type:"object",base:e.object(),coerce:e=>({value:(void 0)(e)})}))),b=g.string().regex(/^\d{15,16}$/).message("Invalid IMEI"),w=g.string().regex(/^[0-9A-Za-z]{18,22}$/).message("Invalid ICCID"),E=g.extend((e=>({type:"imei",messages:"Invalid IMEI",base:e.string().regex(/^\d{15,16}$/)})),(e=>({type:"iccid",messages:"Invalid ICCID",base:e.string().regex(/^[0-9A-Za-z]{18,22}$/)})),(e=>({type:"urlEncodedObject",base:e.object(),coerce:e=>({value:(void 0)(e)})})),(e=>({type:"jsonObject",base:e.object(),coerce(e){try{return{value:JSON.parse(e)}}catch(e){return null}},validate:(e,r)=>e?{value:e}:{value:e,errors:r.error("json.valid")}})),(e=>({type:"delimitedArray",base:e.array().default([]),coerce:e=>({value:e.split?e.split(","):e})})),(e=>({type:"queryStringParameters",messages:"Missing query parameters",base:e.object().required()})),(e=>({type:"date",base:e.date(),prepare(e,t){try{const t=r.tz(e,"UTC");if(t.isValid())return{value:t.toDate()}}catch(e){return t.error("any.invalid")}}})),(e=>({type:"jsonArray",base:e.array(),coerce(e){try{return{value:JSON.parse(e)}}catch(e){return{value:null}}},validate:(e,r)=>Array.isArray(e)?{value:e}:{value:e,errors:r.error("jsonArray.schema")}})),(e=>({type:"base64ThenUriEncodedObject",base:e.object(),coerce(e){try{const r=decodeURIComponent(Buffer.from(e,"base64").toString());return{value:JSON.parse(r)}}catch(e){return null}},validate:(e,r)=>e?{value:e}:{value:e,errors:r.error("json.valid")}})));class f extends Error{}class C extends f{code=400;statusCode=400;name="BadRequestError"}class q extends Error{code;statusCode}class A extends f{code=401;statusCode=401;name="UnauthorizedError"}const j=({scope:e,type:r}={})=>g.object({clientId:g.number(),resources:y.object({}),scope:e?g.string().pattern(new RegExp(`${e}`)).error((()=>new A(`missing scope ${e}`))):g.optional(),type:r?g.any().valid(r).error((()=>new A(`missing user type ${r}`))):g.optional(),enterprise:g.boolean().default(!1),maintenanceModule:g.boolean().default(!1),billingMethod:g.string().optional(),customerSegment:g.string().optional(),securityGroupTagId:g.number().optional().allow(null),securityRole:g.string().optional().allow(null)}),I=g.object({authorizer:j()}),S=(e={})=>g.object({authorizer:j(e)}),N=(r,t,o)=>{if(!t)return e.logger.warn("skipping validation"),r;const{error:s,value:a}=t.validate(r,{allowUnknown:o?.allowUnknown||!0,errors:{label:"key",wrap:{label:!1}}});if(s)throw e.logger.error({error:s},"Validation error"),s.isJoi?new C(s.message):s;return a},O=E.object({requestContext:S()}),R={"Content-Type":"application/json","Access-Control-Allow-Origin":"*","Access-Control-Allow-Credentials":!0},z=(e,r,t)=>({success:e<400,message:r,result:t||void 0}),T=({statusCode:e=200,message:r="ok",data:t,headers:o={},rawResult:s=!1,stringifyBody:a=!0})=>{const n=s?t:z(e,r,t),i=a?n&&JSON.stringify(n):t;return{headers:{...R,...o},statusCode:e,body:i}};const _=()=>"test"===process.env.NODE_ENV?"test":process.env.IS_OFFLINE&&"dev"===process.env.STAGE?"local":process.env.STAGE??process.env.NODE_ENV??"dev",M=()=>"local"===_(),P=()=>"test"===_(),k="_X_AMZN_TRACE_ID",G="x-correlation-",H=`${G}id`,W=`${G}trace-id`,$={before:async({event:r,context:t})=>{const o={awsRequestId:t?.awsRequestId},s=r?.requestContext?.requestId;s&&(o.apiRequestId=s),r.headers&&Object.keys(r.headers).forEach((e=>{e.toLowerCase().startsWith(G)&&(o[e]=r.headers[e])})),process.env[k]&&(o[W]=process.env[k]),o[H]||(o[H]=t.awsRequestId),e.logger.setHapnContext(o)}},B=c({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:r=>{const t=r?.event?"event":"response";e.logger.info(r.event??r.response,t)}}),F={isWarmingUp:e=>"serverless-plugin-warmup"===e.source},J=(e={})=>{const r={...F,...e};return{before:e=>{if(r.isWarmingUp(e.event))return"warmup"}}},U=[J(),$,M()||P()?void 0:B].filter(Boolean),D=[i({serializers:[{regex:/^application\/xml$/,serializer:({body:e})=>`<message>${e}</message>`},{regex:/^application\/json$/,serializer:({body:e})=>JSON.stringify(e)},{regex:/^text\/plain$/,serializer:({body:e})=>e}],default:"application/json"}),{after:e=>{e.response=T(e.response)},onError:r=>{e.logger.error(r.error,"Request failed"),r.response=T({statusCode:r.error.code||500,message:r.error.message||"Error"})}},(({authFunctionName:r="spytec-web-api-auth-prod-AuthorizerFunction",enabled:t=!!process.env.IS_OFFLINE}={})=>{const o=new u.LambdaClient({region:process.env.AWS_REGION});return{before:async s=>{if(!t)return;const{event:a}=s,n=a.headers?.Authorization||a.headers?.authorization;if(!n||!n.startsWith("Bearer "))throw new Error("Authorization header is missing or invalid");const i={authorizationToken:n.slice(7)},l=new u.InvokeCommand({FunctionName:r,Payload:Buffer.from(JSON.stringify(i))});try{const e=await o.send(l),r=JSON.parse(Buffer.from(e.Payload).toString());if(r.errorMessage)throw new Error(r.errorMessage);a.requestContext.authorizer=r.context}catch(r){throw e.logger.error("Error invoking auth function:",r),new Error("Authorization failed")}}}})()];exports.httpErrorHandler=n,exports.httpResponseSerializer=i,exports.sqsJsonBodyParser=l,exports.merge=d,exports.BadRequestError=C,exports.BaseError=q,exports.ConflictError=class extends f{code=409;statusCode=409;name="ConflictError"},exports.ForbiddenError=class extends f{code=403;statusCode=403;name="ForbiddenError"},exports.HttpError=f,exports.LambdaCache=class{collectionName;constructor(e){this.collectionName=e??`${process.env.AWS_LAMBDA_FUNCTION_NAME}-${process.env.AWS_LAMBDA_FUNCTION_VERSION}`,global.CACHE_STORAGE||(global.CACHE_STORAGE={}),global.CACHE_STORAGE[this.collectionName]||(global.CACHE_STORAGE[this.collectionName]=new Map)}set(e,r,t){const o=1e3*t+Date.now();global.CACHE_STORAGE[this.collectionName].set(e,{value:r,expire:o})}get(e){if(!e)throw new Error("key is required!");const r=global.CACHE_STORAGE[this.collectionName].get(e);return r?!r.expire||r.expire>Date.now()?r.value:this.remove(e):null}remove(e){global.CACHE_STORAGE[this.collectionName].get(e)&&global.CACHE_STORAGE[this.collectionName].delete(e)}},exports.NotFoundError=class extends f{code=404;statusCode=404;name="NotFoundError"},exports.SpytecJoi=E,exports.UnauthorizedError=A,exports.apiGatewayEventWrapper=async({event:r,context:t,schema:o,handler:s})=>{r&&t&&e.withRequest(r,t);try{const e=N(r,o),t=await s(e);return T(t)}catch(t){return e.logger.error({err:t,event:(a=r,{resource:a.resource,httpMethod:a.httpMethod,queryStringParameters:a.queryStringParameters,pathParameters:a.pathParameters,body:a.body})},"apiGatewayWrapper - caught error"),T({statusCode:t.code||500,message:t.message||"Error"})}var a},exports.apiGatewayMiddlewares=D,exports.apiGatewayMiddy=e=>a(e).use([...U,...D]),exports.baseMiddlewares=U,exports.buildProxyResult=T,exports.buildResponseBody=z,exports.defaultApiSchema=O,exports.getAuthorizerValidator=j,exports.getEnvKey=_,exports.getRequestContextValidator=S,exports.iccidSchema=w,exports.imeiSchema=b,exports.isDev=()=>"dev"===_(),exports.isLocal=M,exports.isProduction=()=>"prod"===_(),exports.isTest=P,exports.json=y,exports.middy=e=>a(e).use([...U]),exports.promiseWithCache=async(e,r,t,o)=>{let s=r.get(t);return s||(s=await e(),r.set(t,s,o)),s},exports.promiseWithTimeout=(e,r,t=new Error("Promise timed out"))=>{const o=new Promise(((e,o)=>{setTimeout((()=>{o(t)}),r)}));return Promise.race([e,o])},exports.requestContextValidator=I,exports.setupEnvConfig=e=>{const r=e.base,t=e[_()]??{};return d(r,t)},exports.sqsEventWrapper=async({event:r,context:t,schema:o,handler:s,singleHandler:a,mode:n="serial"})=>{r&&t&&e.withRequest(r,t);try{const e=N(r,o);await async function(e,r,t,o){if(!r&&!t)throw new Error("handler or singleHandler not defined");if(r)await r(e);else if(t){const r=e.Records;if("serial"===o)for(const e of r)await t(e);else"parallel"===o&&await Promise.all(r.map((e=>t(e))))}}(e,s,a,n)}catch(t){throw e.logger.error({err:t,event:(i=r,(i.Records||[]).map((e=>({messageId:e.messageId,body:e.body,messageAttributes:e.messageAttributes}))))},"sqsEventWrapper - caught error"),t}var i},exports.sqsEventWrapperWithReturn=async({event:r,context:t,schema:o,handler:s,singleHandler:a,mode:n="serial"})=>{r&&t&&e.withRequest(r,t);try{const e=N(r,o);return await(async(e,r,t,o)=>{if(!r&&!t)throw new Error("handler or singleHandler not defined");if(r)return await r(e);if(t){const r=e.Records;if("serial"===o){const e=[];for(const o of r){const r=await t(o);e.push(r)}return e}if("parallel"===o)return await Promise.all(r.map((e=>t(e))))}})(e,s,a,n)}catch(t){throw e.logger.error({err:t,event:(i=r,(i.Records||[]).map((e=>({messageId:e.messageId,body:e.body,messageAttributes:e.messageAttributes}))))},"sqsEventWrapper - caught error"),t}var i},exports.urlEncoded=x,exports.validateEvent=N,exports.validatorMiddleware=({schema:r,allowUnknown:t=!0})=>({before:o=>{const{error:s,value:a}=r.validate(o.event,{allowUnknown:t,errors:{label:"key",wrap:{label:!1}}});if(s)throw e.logger.error("Validation error",{error:s}),s.isJoi?new C(s.message):s;o.event=a}}),exports.warmupMiddleware=J;
+'use strict';
+
+var sdkLogger = require('@spytecgps/sdk-logger');
+var dayjs = require('dayjs');
+var timezone = require('dayjs/plugin/timezone');
+var utc = require('dayjs/plugin/utc');
+var Joi = require('joi');
+var rawMiddy = 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 merge = require('deepmerge');
+var inputOutputLogger = require('@middy/input-output-logger');
+var clientLambda = require('@aws-sdk/client-lambda');
+
+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 stringify = require('./stringify');
+var parse = require('./parse');
+var formats = require('./formats');
+
+module.exports = {
+    formats: formats,
+    parse: parse,
+    stringify: stringify
+};
+
+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: undefined(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: undefined(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 };
+    },
+}));
+
+class HttpError extends Error {
+}
+
+class BadRequestError extends HttpError {
+    code = 400;
+    statusCode = 400;
+    name = 'BadRequestError';
+}
+
+class BaseError extends Error {
+    code;
+    statusCode;
+}
+
+class ConflictError extends HttpError {
+    code = 409;
+    statusCode = 409;
+    name = 'ConflictError';
+}
+
+class ForbiddenError extends HttpError {
+    code = 403;
+    statusCode = 403;
+    name = 'ForbiddenError';
+}
+
+class NotFoundError extends HttpError {
+    code = 404;
+    statusCode = 404;
+    name = 'NotFoundError';
+}
+
+class UnauthorizedError extends HttpError {
+    code = 401;
+    statusCode = 401;
+    name = 'UnauthorizedError';
+}
+
+const getAuthorizerValidator = ({ scope, type } = {}) => {
+    return Joi__namespace.object({
+        clientId: Joi__namespace.number(),
+        resources: json.object({}),
+        scope: scope
+            ? Joi__namespace.string()
+                .pattern(new RegExp(`${scope}`))
+                .error(() => new UnauthorizedError(`missing scope ${scope}`))
+            : Joi__namespace.optional(),
+        type: type
+            ? Joi__namespace.any()
+                .valid(type)
+                .error(() => new UnauthorizedError(`missing user type ${type}`))
+            : Joi__namespace.optional(),
+        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),
+    });
+};
+/**
+ * @deprecated
+ */
+const requestContextValidator = Joi__namespace.object({
+    authorizer: getAuthorizerValidator(),
+});
+const getRequestContextValidator = (params = {}) => {
+    return Joi__namespace.object({
+        authorizer: getAuthorizerValidator(params),
+    });
+};
+
+const validateEvent = (event, schema, validateOptions) => {
+    if (!schema) {
+        sdkLogger.logger.warn(`skipping validation`);
+        return event;
+    }
+    const { error, value } = schema.validate(event, {
+        allowUnknown: validateOptions?.allowUnknown || true,
+        errors: {
+            label: 'key',
+            wrap: {
+                label: false,
+            },
+        },
+    });
+    if (error) {
+        sdkLogger.logger.error({ error }, 'Validation error');
+        throw error.isJoi ? new BadRequestError(error.message) : error;
+    }
+    return value;
+};
+
+const defaultApiSchema = SpytecJoi.object({
+    requestContext: getRequestContextValidator(),
+});
+
+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: data ? data : undefined,
+    };
+};
+const buildProxyResult = ({ statusCode = 200, message = 'ok', data, headers = {}, rawResult = false, stringifyBody = true, }) => {
+    const resp = rawResult ? data : buildResponseBody(statusCode, message, data);
+    const body = stringifyBody ? resp && JSON.stringify(resp) : data;
+    return {
+        headers: { ...baseHeaders, ...headers },
+        statusCode,
+        body,
+    };
+};
+
+const logEvent$2 = (e) => ({
+    resource: e.resource,
+    httpMethod: e.httpMethod,
+    queryStringParameters: e.queryStringParameters,
+    pathParameters: e.pathParameters,
+    body: e.body,
+});
+const apiGatewayEventWrapper = async ({ event, context, schema, handler, }) => {
+    if (event && context) {
+        sdkLogger.withRequest(event, context);
+    }
+    try {
+        const validatedEvent = validateEvent(event, schema);
+        const result = await handler(validatedEvent);
+        return buildProxyResult(result);
+    }
+    catch (err) {
+        sdkLogger.logger.error({ err, event: logEvent$2(event) }, `apiGatewayWrapper - caught error`);
+        return buildProxyResult({
+            statusCode: err.code || 500,
+            message: err.message || 'Error',
+        });
+    }
+};
+
+const logEvent$1 = (e) => (e.Records || []).map((record) => ({
+    messageId: record.messageId,
+    body: record.body,
+    messageAttributes: record.messageAttributes,
+}));
+async function processEvent$1(validatedEvent, handler, singleHandler, mode) {
+    if (!(handler || singleHandler)) {
+        throw new Error(`handler or singleHandler not defined`);
+    }
+    if (handler) {
+        await handler(validatedEvent);
+    }
+    else if (singleHandler) {
+        const records = validatedEvent.Records;
+        if (mode === 'serial') {
+            for (const record of records) {
+                await singleHandler(record);
+            }
+        }
+        else if (mode === 'parallel') {
+            await Promise.all(records.map((record) => singleHandler(record)));
+        }
+    }
+}
+const sqsEventWrapper$1 = async ({ event, context, schema, handler, singleHandler, mode = 'serial', }) => {
+    if (event && context) {
+        sdkLogger.withRequest(event, context);
+    }
+    try {
+        const validatedEvent = validateEvent(event, schema);
+        await processEvent$1(validatedEvent, handler, singleHandler, mode);
+    }
+    catch (err) {
+        sdkLogger.logger.error({ err, event: logEvent$1(event) }, `sqsEventWrapper - caught error`);
+        throw err;
+    }
+};
+
+const logEvent = (e) => (e.Records || []).map((record) => ({
+    messageId: record.messageId,
+    body: record.body,
+    messageAttributes: record.messageAttributes,
+}));
+const processEvent = async (validatedEvent, handler, singleHandler, mode) => {
+    if (!(handler || singleHandler)) {
+        throw new Error(`handler or singleHandler not defined`);
+    }
+    if (handler) {
+        return await handler(validatedEvent);
+    }
+    else if (singleHandler) {
+        const records = validatedEvent.Records;
+        if (mode === 'serial') {
+            const result = [];
+            for (const record of records) {
+                const singleHandleResult = await singleHandler(record);
+                result.push(singleHandleResult);
+            }
+            return result;
+        }
+        else if (mode === 'parallel') {
+            return await Promise.all(records.map((record) => singleHandler(record)));
+        }
+    }
+};
+const sqsEventWrapper = async ({ event, context, schema, handler, singleHandler, mode = 'serial', }) => {
+    if (event && context) {
+        sdkLogger.withRequest(event, context);
+    }
+    try {
+        const validatedEvent = validateEvent(event, schema);
+        return await processEvent(validatedEvent, handler, singleHandler, mode);
+    }
+    catch (err) {
+        sdkLogger.logger.error({ err, event: logEvent(event) }, `sqsEventWrapper - caught error`);
+        throw err;
+    }
+};
+
+const getEnvKey = () => {
+    if (process.env.NODE_ENV === 'test') {
+        return 'test';
+    }
+    if (process.env.IS_OFFLINE && process.env.STAGE === 'dev') {
+        return 'local';
+    }
+    return (process.env.STAGE ?? process.env.NODE_ENV ?? 'dev');
+};
+const isLocal = () => getEnvKey() === 'local';
+const isTest = () => getEnvKey() === 'test';
+const isDev = () => getEnvKey() === 'dev';
+const isProduction = () => getEnvKey() === 'prod';
+const setupEnvConfig = (envConfigs) => {
+    const baseConfig = envConfigs['base'];
+    const envConfig = envConfigs[getEnvKey()] ?? {};
+    return merge(baseConfig, envConfig);
+};
+
+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 = () => {
+    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;
+        }
+        sdkLogger.logger.setHapnContext(ctx);
+    };
+    return {
+        before,
+    };
+};
+const contextualLoggerMiddleware = contextualLogger();
+
+const ioLoggerMiddleware = 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) => {
+        const message = req?.event ? 'event' : 'response';
+        sdkLogger.logger.info(req.event ?? req.response, message);
+    },
+});
+
+const offlineAuthMiddleware = ({ authFunctionName = 'spytec-web-api-auth-prod-AuthorizerFunction', enabled = !!process.env.IS_OFFLINE, } = {}) => {
+    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');
+            }
+            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) {
+                sdkLogger.logger.error('Error invoking auth function:', error);
+                throw new Error('Authorization failed');
+            }
+        },
+    };
+};
+
+const responseWrapperMiddleware = () => {
+    const responseWrapperMiddlewareAfter = (req) => {
+        req.response = buildProxyResult(req.response);
+    };
+    const responseWrapperMiddlewareError = (req) => {
+        sdkLogger.logger.error(req.error, 'Request failed');
+        req.response = buildProxyResult({
+            statusCode: req.error.code || 500,
+            message: req.error.message || 'Error',
+        });
+    };
+    return {
+        after: responseWrapperMiddlewareAfter,
+        onError: responseWrapperMiddlewareError,
+    };
+};
+
+const validatorMiddleware = ({ schema, allowUnknown = true }) => {
+    const validatorMiddlewareBefore = (request) => {
+        const { error, value } = schema.validate(request.event, {
+            allowUnknown,
+            errors: {
+                label: 'key',
+                wrap: {
+                    label: false,
+                },
+            },
+        });
+        if (error) {
+            sdkLogger.logger.error('Validation error', { error });
+            throw error.isJoi ? new BadRequestError(error.message) : error;
+        }
+        request.event = value;
+    };
+    return {
+        before: validatorMiddlewareBefore,
+    };
+};
+
+/* 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,
+    };
+};
+
+const baseMiddlewares = [
+    warmupMiddleware(),
+    contextualLoggerMiddleware,
+    !(isLocal() || isTest()) ? ioLoggerMiddleware : undefined,
+].filter(Boolean);
+const apiGatewayMiddlewares = [
+    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',
+    }),
+    responseWrapperMiddleware(),
+    offlineAuthMiddleware(),
+];
+const middy = (handler) => rawMiddy(handler).use([...baseMiddlewares]);
+const apiGatewayMiddy = (handler) => rawMiddy(handler).use([...baseMiddlewares, ...apiGatewayMiddlewares]);
+
+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);
+    }
+}
+
+const promiseWithCache = async (promise, cacheInstance, cacheKey, ttl) => {
+    let instance = cacheInstance.get(cacheKey);
+    if (!instance) {
+        instance = await promise();
+        cacheInstance.set(cacheKey, instance, ttl);
+    }
+    return instance;
+};
+
+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.httpErrorHandler = httpErrorHandler;
+exports.httpResponseSerializer = httpResponseSerializer;
+exports.sqsJsonBodyParser = sqsJsonBodyParser;
+exports.merge = merge;
+exports.BadRequestError = BadRequestError;
+exports.BaseError = BaseError;
+exports.ConflictError = ConflictError;
+exports.ForbiddenError = ForbiddenError;
+exports.HttpError = HttpError;
+exports.LambdaCache = LambdaCache;
+exports.NotFoundError = NotFoundError;
+exports.SpytecJoi = SpytecJoi;
+exports.UnauthorizedError = UnauthorizedError;
+exports.apiGatewayEventWrapper = apiGatewayEventWrapper;
+exports.apiGatewayMiddlewares = apiGatewayMiddlewares;
+exports.apiGatewayMiddy = apiGatewayMiddy;
+exports.baseMiddlewares = baseMiddlewares;
+exports.buildProxyResult = buildProxyResult;
+exports.buildResponseBody = buildResponseBody;
+exports.defaultApiSchema = defaultApiSchema;
+exports.getAuthorizerValidator = getAuthorizerValidator;
+exports.getEnvKey = getEnvKey;
+exports.getRequestContextValidator = getRequestContextValidator;
+exports.iccidSchema = iccidSchema;
+exports.imeiSchema = imeiSchema;
+exports.isDev = isDev;
+exports.isLocal = isLocal;
+exports.isProduction = isProduction;
+exports.isTest = isTest;
+exports.json = json;
+exports.middy = middy;
+exports.promiseWithCache = promiseWithCache;
+exports.promiseWithTimeout = promiseWithTimeout;
+exports.requestContextValidator = requestContextValidator;
+exports.setupEnvConfig = setupEnvConfig;
+exports.sqsEventWrapper = sqsEventWrapper$1;
+exports.sqsEventWrapperWithReturn = sqsEventWrapper;
+exports.urlEncoded = urlEncoded;
+exports.validateEvent = validateEvent;
+exports.validatorMiddleware = validatorMiddleware;
+exports.warmupMiddleware = warmupMiddleware;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spytecgps/lambda-utils",
-  "version": "2.3.10",
+  "version": "2.3.12",
   "description": "Lambda Utils",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,7 +33,7 @@
     "@middy/http-response-serializer": "^2.5.7",
     "@middy/input-output-logger": "^2.5.7",
     "@middy/sqs-json-body-parser": "^2.5.7",
-    "@spytecgps/sdk-logger": "^2.0.6",
+    "@spytecgps/sdk-logger": "^2.0.8",
     "dayjs": "^1.11.11",
     "deepmerge": "^4.3.1",
     "joi": "^17.13.0",
@@ -66,7 +66,6 @@
     "rollup": "^4.24.0",
     "rollup-plugin-peer-deps-external": "^2.2.4",
     "ts-jest": "^29.0.3",
-    "ts-loader": "^9.5.1",
     "typescript": "^5.6.3"
   },
   "files": [