@spytecgps/lambda-utils 2.4.0 → 3.0.1

package/dist/config/index.d.ts

@@ -7,6 +7,7 @@ export type EnvConfigsParam<T> = {
     [k: string]: DeepPartial<T>;
 };
 export declare const getEnvKey: () => Env;
+export declare const isOffline: () => boolean;
 export declare const isLocal: () => boolean;
 export declare const isTest: () => boolean;
 export declare const isDev: () => boolean;

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-export * from './wrappers';
+export * from './config';
 export * from './errors';
-export * from './validation';
-export * from './types';
 export * from './middleware';
+export * from './types';
 export * from './utils';
-export * from './config';
+export * from './validation';

package/dist/index.js

@@ -1 +1,653 @@
-import{logger as e,withRequest as r}from"@spytecgps/sdk-logger";import t from"dayjs";import s from"dayjs/plugin/timezone";import o from"dayjs/plugin/utc";import*as a from"joi";import*as n from"qs";import i from"@middy/core";export{default as httpErrorHandler}from"@middy/http-error-handler";import l from"@middy/http-response-serializer";export{default as httpResponseSerializer}from"@middy/http-response-serializer";export{default as sqsJsonBodyParser}from"@middy/sqs-json-body-parser";import c from"deepmerge";export{default as merge}from"deepmerge";import d from"@middy/input-output-logger";import{LambdaClient as u,InvokeCommand as p}from"@aws-sdk/client-lambda";t.extend(o),t.extend(s);const m=a.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")}}))),v=a.extend((e=>({type:"object",base:e.object(),coerce:e=>({value:n.parse(e)})}))),g=a.string().regex(/^\d{15,16}$/).message("Invalid IMEI"),h=a.string().regex(/^[0-9A-Za-z]{18,22}$/).message("Invalid ICCID"),y=a.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:n.parse(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,r){try{const r=t.tz(e,"UTC");if(r.isValid())return{value:r.toDate()}}catch(e){return r.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 b extends Error{}class f extends b{code=400;statusCode=400;name="BadRequestError"}class w extends Error{code;statusCode}class C extends b{code=409;statusCode=409;name="ConflictError"}class E extends b{code=403;statusCode=403;name="ForbiddenError"}class x extends b{code=404;statusCode=404;name="NotFoundError"}class A extends b{code=401;statusCode=401;name="UnauthorizedError"}const q=({scope:e,type:r}={})=>a.object({clientId:a.number(),resources:m.object({}),scope:e?a.string().pattern(new RegExp(`${e}`)).error((()=>new A(`missing scope ${e}`))):a.optional(),type:r?a.any().valid(r).error((()=>new A(`missing user type ${r}`))):a.optional(),enterprise:a.boolean().default(!1),maintenanceModule:a.boolean().default(!1),billingMethod:a.string().optional(),customerSegment:a.string().optional(),securityGroupTagId:a.number().optional().allow(null),securityRole:a.string().optional().allow(null)}),I=a.object({authorizer:q()}),N=(e={})=>a.object({authorizer:q(e)}),S=(r,t,s)=>{if(!t)return e.warn("skipping validation"),r;const{error:o,value:a}=t.validate(r,{allowUnknown:s?.allowUnknown||!0,errors:{label:"key",wrap:{label:!1}}});if(o)throw e.error({error:o},"Validation error"),o.isJoi?new f(o.message):o;return a},j=y.object({requestContext:N()}),O={"Content-Type":"application/json","Access-Control-Allow-Origin":"*","Access-Control-Allow-Credentials":!0},R=(e,r,t)=>({success:e<400,message:r,result:t||void 0}),_=({statusCode:e=200,message:r="ok",data:t,headers:s={},rawResult:o=!1,stringifyBody:a=!0})=>{const n=o?t:R(e,r,t),i=a?n&&JSON.stringify(n):t;return{headers:{...O,...s},statusCode:e,body:i}},z=async({event:t,context:s,schema:o,handler:a})=>{t&&s&&r(t,s);try{const e=S(t,o),r=await a(e);return _(r)}catch(r){return e.error({err:r,event:(n=t,{resource:n.resource,httpMethod:n.httpMethod,queryStringParameters:n.queryStringParameters,pathParameters:n.pathParameters,body:n.body})},"apiGatewayWrapper - caught error"),_({statusCode:r.code||500,message:r.message||"Error"})}var n};const T=async({event:t,context:s,schema:o,handler:a,singleHandler:n,mode:i="serial"})=>{t&&s&&r(t,s);try{const e=S(t,o);await async function(e,r,t,s){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"===s)for(const e of r)await t(e);else"parallel"===s&&await Promise.all(r.map((e=>t(e))))}}(e,a,n,i)}catch(r){throw e.error({err:r,event:(l=t,(l.Records||[]).map((e=>({messageId:e.messageId,body:e.body,messageAttributes:e.messageAttributes}))))},"sqsEventWrapper - caught error"),r}var l},P=async({event:t,context:s,schema:o,handler:a,singleHandler:n,mode:i="serial"})=>{t&&s&&r(t,s);try{const e=S(t,o);return await(async(e,r,t,s)=>{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"===s){const e=[];for(const s of r){const r=await t(s);e.push(r)}return e}if("parallel"===s)return await Promise.all(r.map((e=>t(e))))}})(e,a,n,i)}catch(r){throw e.error({err:r,event:(l=t,(l.Records||[]).map((e=>({messageId:e.messageId,body:e.body,messageAttributes:e.messageAttributes}))))},"sqsEventWrapper - caught error"),r}var l},M=()=>"test"===process.env.NODE_ENV?"test":process.env.IS_OFFLINE&&"dev"===process.env.STAGE?"local":process.env.STAGE??process.env.NODE_ENV??"dev",H=()=>"local"===M(),$=()=>"test"===M(),k=()=>"dev"===M(),G=()=>"prod"===M(),W=e=>{const r=e.base,t=e[M()]??{};return c(r,t)},J="_X_AMZN_TRACE_ID",U="x-correlation-",B=`${U}id`,F=`${U}trace-id`,D={before:async({event:r,context:t})=>{const s={awsRequestId:t?.awsRequestId},o=r?.requestContext?.requestId;o&&(s.apiRequestId=o),r.headers&&Object.keys(r.headers).forEach((e=>{e.toLowerCase().startsWith(U)&&(s[e]=r.headers[e])})),process.env[J]&&(s[F]=process.env[J]),s[B]||(s[B]=t.awsRequestId),e.setHapnContext(s)}},V=d({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.info(r.event??r.response,t)}}),L=({schema:r,allowUnknown:t=!0})=>({before:s=>{const{error:o,value:a}=r.validate(s.event,{allowUnknown:t,errors:{label:"key",wrap:{label:!1}}});if(o)throw e.error("Validation error",{error:o}),o.isJoi?new f(o.message):o;s.event=a}}),Z={isWarmingUp:e=>"serverless-plugin-warmup"===e.source},Q=(e={})=>{const r={...Z,...e};return{before:e=>{if(r.isWarmingUp(e.event))return"warmup"}}},X=[Q(),D,H()||$()?void 0:V].filter(Boolean),K=[l({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=_(e.response)},onError:r=>{e.error(r.error,"Request failed"),r.response=_({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 s=new u({region:process.env.AWS_REGION});return{before:async o=>{if(!t)return;const{event:a}=o,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 p({FunctionName:r,Payload:Buffer.from(JSON.stringify(i))});try{const e=await s.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.error("Error invoking auth function:",r),new Error("Authorization failed")}}}})()],Y=e=>i(e).use([...X]),ee=e=>i(e).use([...X,...K]);class re{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 s=1e3*t+Date.now();global.CACHE_STORAGE[this.collectionName].set(e,{value:r,expire:s})}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)}}const te=async(e,r,t,s)=>{let o=r.get(t);return o||(o=await e(),r.set(t,o,s)),o},se=(e,r,t=new Error("Promise timed out"))=>{const s=new Promise(((e,s)=>{setTimeout((()=>{s(t)}),r)}));return Promise.race([e,s])};export{f as BadRequestError,w as BaseError,C as ConflictError,E as ForbiddenError,b as HttpError,re as LambdaCache,x as NotFoundError,y as SpytecJoi,A as UnauthorizedError,z as apiGatewayEventWrapper,K as apiGatewayMiddlewares,ee as apiGatewayMiddy,X as baseMiddlewares,_ as buildProxyResult,R as buildResponseBody,j as defaultApiSchema,q as getAuthorizerValidator,M as getEnvKey,N as getRequestContextValidator,h as iccidSchema,g as imeiSchema,k as isDev,H as isLocal,G as isProduction,$ as isTest,m as json,Y as middy,te as promiseWithCache,se as promiseWithTimeout,I as requestContextValidator,W as setupEnvConfig,T as sqsEventWrapper,P as sqsEventWrapperWithReturn,v as urlEncoded,S as validateEvent,L as validatorMiddleware,Q as warmupMiddleware};
+'use strict';
+
+var merge = require('deepmerge');
+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 inputOutputLogger = require('@middy/input-output-logger');
+var clientLambda = require('@aws-sdk/client-lambda');
+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);
+
+const getEnvKey = () => {
+    if (process.env.NODE_ENV === 'test') {
+        return 'test';
+    }
+    if (isOffline() && process.env.STAGE === 'dev') {
+        return 'local';
+    }
+    return (process.env.STAGE ?? process.env.NODE_ENV ?? 'dev');
+};
+const isOffline = () => !!process.env.IS_OFFLINE;
+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);
+};
+
+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 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,
+    };
+};
+
+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 (isLocal() || isTest()) {
+            return;
+        }
+        const message = req?.event ? 'event' : 'response';
+        logger.info(req.event ?? req.response, message);
+    },
+});
+
+const normalizerMiddleware = () => {
+    return {
+        before: async (request) => {
+            const event = request.event;
+            event.queryStringParameters = event.queryStringParameters || {};
+            event.pathParameters = event.pathParameters || {};
+        },
+    };
+};
+
+const offlineAuth = ({ authFunctionName = 'spytec-web-api-auth-prod-AuthorizerFunctionV4', enabled = 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');
+            }
+        },
+    };
+};
+
+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,
+    };
+};
+
+const responseWrapper = ({ logger }) => {
+    const responseWrapperMiddlewareAfter = (req) => {
+        req.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 = buildProxyResult({
+            statusCode,
+            message: errorMessage,
+        });
+    };
+    return {
+        after: responseWrapperMiddlewareAfter,
+        onError: responseWrapperMiddlewareError,
+    };
+};
+
+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(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,
+    };
+};
+
+// Function that returns base middlewares with required logger
+const getBaseMiddlewares = ({ logger }) => [
+    warmupMiddleware(),
+    contextualLogger({ logger }),
+    ioLogger({ logger }),
+];
+// Function that returns API Gateway middlewares with required logger
+const getApiGatewayMiddlewares = ({ logger, offlineAuthEnabled = true }) => [
+    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({ logger }),
+    offlineAuth({ logger, enabled: offlineAuthEnabled }),
+    normalizerMiddleware(),
+];
+
+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
+};
+
+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 };
+    },
+}));
+
+const getAuthorizerValidator = (params = {}) => {
+    return Joi__namespace.object({
+        clientId: Joi__namespace.number().greater(0).required(),
+        userId: Joi__namespace.string().guid( /*{ version: 'uuidv4' }*/).required(),
+        resources: 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),
+    });
+};
+
+/**
+ * @deprecated
+ */
+const validateEvent = (event, schema, validateOptions) => {
+    if (!schema) {
+        console.warn(`skipping validation`);
+        return event;
+    }
+    const { error, value } = schema.validate(event, {
+        allowUnknown: validateOptions?.allowUnknown || true,
+        errors: {
+            label: 'key',
+            wrap: {
+                label: false,
+            },
+        },
+    });
+    if (error) {
+        console.error({ error }, 'Validation error');
+        throw error.isJoi ? new BadRequestError(error.message) : error;
+    }
+    return value;
+};
+
+const defaultApiSchema = SpytecJoi.object({
+    requestContext: getRequestContextValidator(),
+});
+
+exports.merge = merge;
+exports.middy = core;
+exports.httpErrorHandler = httpErrorHandler;
+exports.httpResponseSerializer = httpResponseSerializer;
+exports.sqsJsonBodyParser = sqsJsonBodyParser;
+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.contextualLogger = contextualLogger;
+exports.defaultApiSchema = defaultApiSchema;
+exports.getApiGatewayMiddlewares = getApiGatewayMiddlewares;
+exports.getAuthorizerValidator = getAuthorizerValidator;
+exports.getAuthorizerValidatorV4 = getAuthorizerValidatorV4;
+exports.getBaseMiddlewares = getBaseMiddlewares;
+exports.getEnvKey = getEnvKey;
+exports.getRequestContextValidator = getRequestContextValidator;
+exports.getRequestContextValidatorV4 = getRequestContextValidatorV4;
+exports.iccidSchema = iccidSchema;
+exports.imeiSchema = imeiSchema;
+exports.ioLogger = ioLogger;
+exports.isDev = isDev;
+exports.isLocal = isLocal;
+exports.isOffline = isOffline;
+exports.isProduction = isProduction;
+exports.isTest = isTest;
+exports.json = json;
+exports.offlineAuth = offlineAuth;
+exports.promiseWithCache = promiseWithCache;
+exports.promiseWithTimeout = promiseWithTimeout;
+exports.requestContextValidator = requestContextValidator;
+exports.responseWrapper = responseWrapper;
+exports.setupEnvConfig = setupEnvConfig;
+exports.urlEncoded = urlEncoded;
+exports.validateEvent = validateEvent;
+exports.validator = validator;
+exports.warmupMiddleware = warmupMiddleware;

package/dist/middleware/contextualLogger.d.ts

@@ -1,12 +1,11 @@
-export declare const contextualLogger: () => {
-    before: ({ event, context }: {
-        event: any;
-        context: any;
-    }) => Promise<void>;
-};
-export declare const contextualLoggerMiddleware: {
+import { HapnLogger } from '@spytecgps/sdk-logger';
+interface ContextualLoggerOptions {
+    logger: HapnLogger;
+}
+export declare const contextualLogger: ({ logger }: ContextualLoggerOptions) => {
     before: ({ event, context }: {
         event: any;
         context: any;
     }) => Promise<void>;
 };
+export {};

package/dist/{wrappers → middleware/http}/response.d.ts

@@ -1,8 +1,8 @@
 import { APIGatewayProxyResult } from 'aws-lambda';
-import { HandlerResponse } from '../types';
+import { HandlerResponse } from '../../types';
 export declare const buildResponseBody: <T>(statusCode: number, message: string, data?: T) => {
     success: boolean;
     message: string;
     result: T | undefined;
 };
-export declare const buildProxyResult: <R>({ statusCode, message, data, headers, rawResult, stringifyBody, }: HandlerResponse<R>) => APIGatewayProxyResult;
+export declare const buildProxyResult: <R>({ statusCode, message, data, headers, multiValueHeaders, rawResult, stringifyBody, }: HandlerResponse<R>) => APIGatewayProxyResult;

package/dist/middleware/index.d.ts

@@ -1,25 +1,33 @@
-import rawMiddy from '@middy/core';
+import middy from '@middy/core';
 import httpErrorHandler from '@middy/http-error-handler';
 import httpResponseSerializer from '@middy/http-response-serializer';
 import sqsJsonBodyParser from '@middy/sqs-json-body-parser';
-import { Context as LambdaContext } from 'aws-lambda/handler';
-import { MiddyInputHandler } from './types';
-import { validatorMiddleware } from './validation';
+import { HapnLogger } from '@spytecgps/sdk-logger';
+import { contextualLogger } from './contextualLogger';
+import { ioLogger } from './ioLogger';
+import { offlineAuth } from './offlineAuthorizer';
+import { responseWrapper } from './responseWrapper';
+import { validator } from './validation';
 import { warmupMiddleware } from './warmup';
-declare const baseMiddlewares: ({
+interface BaseMiddlewaresOptions {
+    logger: HapnLogger;
+}
+interface ApiGatewayMiddlewaresOptions {
+    logger: HapnLogger;
+    offlineAuthEnabled?: boolean;
+}
+declare const getBaseMiddlewares: ({ logger }: BaseMiddlewaresOptions) => ({
     before: ({ event, context }: {
         event: any;
         context: any;
     }) => Promise<void>;
-} | rawMiddy.MiddlewareObj<any, any, Error, LambdaContext> | {
+} | middy.MiddlewareObj<any, any, Error, import("aws-lambda").Context> | {
     before: (request: any) => string;
 })[];
-declare const apiGatewayMiddlewares: (rawMiddy.MiddlewareObj<any, any, Error, LambdaContext> | {
+declare const getApiGatewayMiddlewares: ({ logger, offlineAuthEnabled }: ApiGatewayMiddlewaresOptions) => (middy.MiddlewareObj<any, any, Error, import("aws-lambda").Context> | {
     before: (request: any) => Promise<void>;
 } | {
     after: (req: any) => void;
     onError: (req: any) => void;
 })[];
-declare const middy: <TEvent, TResult, TContext extends LambdaContext>(handler: MiddyInputHandler<TEvent, TResult, TContext>) => rawMiddy.MiddyfiedHandler<TEvent, TResult, Error, TContext>;
-declare const apiGatewayMiddy: <TEvent, TResult, TContext extends LambdaContext>(handler: MiddyInputHandler<TEvent, TResult, TContext>) => rawMiddy.MiddyfiedHandler<TEvent, TResult, Error, TContext>;
-export { apiGatewayMiddlewares, apiGatewayMiddy, baseMiddlewares, httpErrorHandler, httpResponseSerializer, middy, sqsJsonBodyParser, validatorMiddleware, warmupMiddleware, };
+export { contextualLogger, getApiGatewayMiddlewares, getBaseMiddlewares, httpErrorHandler, httpResponseSerializer, ioLogger, middy, offlineAuth, responseWrapper, sqsJsonBodyParser, validator, warmupMiddleware, };

package/dist/middleware/ioLogger.d.ts

@@ -1 +1,6 @@
-export declare const ioLoggerMiddleware: import("@middy/core").MiddlewareObj<any, any, Error, import("aws-lambda").Context>;
+import { HapnLogger } from '@spytecgps/sdk-logger';
+interface IoLoggerOptions {
+    logger: HapnLogger;
+}
+export declare const ioLogger: ({ logger }: IoLoggerOptions) => import("@middy/core").MiddlewareObj<any, any, Error, import("aws-lambda").Context>;
+export {};

package/dist/middleware/normalizer.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizerMiddleware: () => {
+    before: (request: any) => Promise<void>;
+};

package/dist/middleware/offlineAuthorizer.d.ts

@@ -1,8 +1,10 @@
-interface OfflineMiddlewareOptions {
+import { HapnLogger } from '@spytecgps/sdk-logger';
+interface OfflineAuthOptions {
     authFunctionName?: string;
     enabled?: boolean;
+    logger: HapnLogger;
 }
-export declare const offlineAuthMiddleware: ({ authFunctionName, enabled, }?: OfflineMiddlewareOptions) => {
+export declare const offlineAuth: ({ authFunctionName, enabled, logger, }: OfflineAuthOptions) => {
     before: (request: any) => Promise<void>;
 };
 export {};

package/dist/middleware/responseWrapper.d.ts

@@ -1,4 +1,9 @@
-export declare const responseWrapperMiddleware: () => {
+import { HapnLogger } from '@spytecgps/sdk-logger';
+interface ResponseWrapperOptions {
+    logger: HapnLogger;
+}
+export declare const responseWrapper: ({ logger }: ResponseWrapperOptions) => {
     after: (req: any) => void;
     onError: (req: any) => void;
 };
+export {};

package/dist/middleware/validation.d.ts

@@ -1,9 +1,11 @@
+import { HapnLogger } from '@spytecgps/sdk-logger';
 import Joi from 'joi';
-interface ValidatorOpts {
+interface ValidatorOptions {
     schema: Joi.Schema;
     allowUnknown?: boolean;
+    logger: HapnLogger;
 }
-export declare const validatorMiddleware: ({ schema, allowUnknown }: ValidatorOpts) => {
+export declare const validator: ({ schema, allowUnknown, logger }: ValidatorOptions) => {
     before: (request: any) => void;
 };
 export {};

package/dist/types.d.ts

@@ -46,6 +46,9 @@ export interface HandlerResponse<R> {
     headers?: {
         [header: string]: boolean | number | string;
     };
+    multiValueHeaders?: {
+        [header: string]: (boolean | number | string)[];
+    };
     isBase64Encoded?: boolean;
     message?: string;
     data?: R;
@@ -72,3 +75,12 @@ export type SQSWrapperArgsWithReturn<RecordType extends BaseRecord, T> = {
     singleHandler?: (record: RecordType) => T | Promise<T>;
     mode?: 'serial' | 'parallel';
 };
+export interface SpytecAuthContextV4 {
+    type: AuthClass;
+    userId?: string;
+    clientId: number;
+    principalId: string;
+    scope?: string;
+}
+export type BaseAPIGatewayEventV4 = Omit<APIGatewayProxyEventBase<SpytecAuthContextV4>, 'pathParameters' | 'queryStringParameters' | 'body'>;
+export type UserAPIHandlerV4<TEvent = APIGatewayProxyWithLambdaAuthorizerEvent<SpytecAuthContextV4>, TResult = any> = (event: TEvent, context: APIGatewayEventRequestContext, callback: Callback<TResult>) => void | Promise<TResult>;

package/dist/validation/requestContext.d.ts

@@ -1,14 +1,14 @@
 import { APIGatewayEventRequestContextWithAuthorizer } from 'aws-lambda/common/api-gateway';
 import * as Joi from 'joi';
-import { AuthClass, SpytecAuthContext } from '../types';
-interface GetAuthorizerValidatorParams {
-    scope?: string;
-    type?: AuthClass;
-}
-export declare const getAuthorizerValidator: ({ scope, type }?: GetAuthorizerValidatorParams) => Joi.ObjectSchema<SpytecAuthContext>;
+import { SpytecAuthContext, SpytecAuthContextV4 } from '../types';
+type GetAuthorizerValidatorParams = Partial<Record<keyof SpytecAuthContext, Joi.AnySchema>>;
+type GetAuthorizerValidatorParamsV4 = Partial<Record<keyof SpytecAuthContextV4, Joi.AnySchema>>;
+export declare const getAuthorizerValidator: (params?: GetAuthorizerValidatorParams) => Joi.ObjectSchema<SpytecAuthContext>;
+export declare const getAuthorizerValidatorV4: (params?: GetAuthorizerValidatorParamsV4) => Joi.ObjectSchema<SpytecAuthContext>;
 /**
  * @deprecated
  */
 export declare const requestContextValidator: Joi.ObjectSchema<any>;
 export declare const getRequestContextValidator: (params?: GetAuthorizerValidatorParams) => Joi.ObjectSchema<APIGatewayEventRequestContextWithAuthorizer<SpytecAuthContext>>;
+export declare const getRequestContextValidatorV4: (params?: GetAuthorizerValidatorParamsV4) => Joi.ObjectSchema<APIGatewayEventRequestContextWithAuthorizer<SpytecAuthContextV4>>;
 export {};

package/dist/validation/validateEvent.d.ts

@@ -1,3 +1,6 @@
 import { ObjectSchema, ValidationOptions } from 'joi';
+/**
+ * @deprecated
+ */
 declare const validateEvent: <T>(event: any, schema?: ObjectSchema<T>, validateOptions?: ValidationOptions) => T;
 export default validateEvent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spytecgps/lambda-utils",
-  "version": "2.4.0",
+  "version": "3.0.1",
   "description": "Lambda Utils",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,19 +33,22 @@
     "@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",
-    "dayjs": "^1.11.11",
+    "dayjs": "^1.11.13",
     "deepmerge": "^4.3.1",
-    "joi": "^17.13.0",
+    "joi": "^17.13.3",
     "qs": "^6.10.1"
   },
+  "peerDependencies": {
+    "@spytecgps/sdk-logger": "^2.0.18"
+  },
   "devDependencies": {
-    "@aws-sdk/client-lambda": "^3.699.0",
-    "@rollup/plugin-commonjs": "^23.0.2",
+    "@aws-sdk/client-lambda": "^3.731.1",
+    "@rollup/plugin-commonjs": "^28.0.2",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-node-resolve": "^16.0.0",
     "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^9.0.2",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@spytecgps/sdk-logger": "^2.0.18",
     "@types/aws-lambda": "^8.10.76",
     "@types/jest": "^29.5.12",
     "@types/joi": "^17.2.3",
@@ -66,10 +69,9 @@
     "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": [
     "dist/**/*"
   ]
-}
+}

package/dist/logger/index.d.ts

@@ -1,2 +0,0 @@
-import { logger, withRequest } from '@spytecgps/sdk-logger';
-export { logger, withRequest };

package/dist/wrappers/apiGatewayEventWrapper.d.ts

@@ -1,4 +0,0 @@
-import { APIGatewayProxyResult } from 'aws-lambda';
-import { WrapperArgs } from '../types';
-declare const apiGatewayEventWrapper: <E, R>({ event, context, schema, handler, }: WrapperArgs<E, R>) => Promise<APIGatewayProxyResult>;
-export default apiGatewayEventWrapper;

package/dist/wrappers/index.d.ts

@@ -1,5 +0,0 @@
-import apiGatewayEventWrapper from './apiGatewayEventWrapper';
-import sqsEventWrapper from './sqsEventWrapper';
-import sqsEventWrapperWithReturn from './sqsEventWrapperWithReturn';
-export { apiGatewayEventWrapper, sqsEventWrapper, sqsEventWrapperWithReturn };
-export * from './response';

package/dist/wrappers/sqsEventWrapper.d.ts

@@ -1,3 +0,0 @@
-import { BaseRecord, SQSWrapperArgs } from '../types';
-declare const sqsEventWrapper: <RecordType extends BaseRecord>({ event, context, schema, handler, singleHandler, mode, }: SQSWrapperArgs<RecordType>) => Promise<void>;
-export default sqsEventWrapper;

package/dist/wrappers/sqsEventWrapperWithReturn.d.ts

@@ -1,3 +0,0 @@
-import { BaseRecord, SQSWrapperArgsWithReturn } from '../types';
-declare const sqsEventWrapper: <RecordType extends BaseRecord, T>({ event, context, schema, handler, singleHandler, mode, }: SQSWrapperArgsWithReturn<RecordType, T>) => Promise<T | T[]>;
-export default sqsEventWrapper;