@spytecgps/lambda-utils 2.3.28 → 3.0.0

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,18 +1,17 @@
 '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 qs = require('qs');
-var rawMiddy = require('@middy/core');
+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 merge = require('deepmerge');
 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);
@@ -34,180 +33,24 @@ function _interopNamespaceDefault(e) {
 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 };
-    },
-}));
-
-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 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 getRequestContextValidatorV4 = (params = {}) => {
-    return Joi__namespace.object({
-        authorizer: getAuthorizerValidatorV4(params),
-    });
+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 {
@@ -237,193 +80,22 @@ class ForbiddenError extends HttpError {
 }
 
 class NotFoundError extends HttpError {
-    code = 404;
-    statusCode = 404;
-    name = 'NotFoundError';
-}
-
-class UnauthorizedError extends HttpError {
-    code = 401;
-    statusCode = 401;
-    name = 'UnauthorizedError';
-}
-
-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: 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 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;
-    }
-};
+    code = 404;
+    statusCode = 404;
+    name = 'NotFoundError';
+}
 
-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);
-};
+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 = () => {
+const contextualLogger = ({ logger }) => {
     const before = async ({ event, context }) => {
         const ctx = {
             awsRequestId: context?.awsRequestId,
@@ -451,15 +123,14 @@ const contextualLogger = () => {
         if (!ctx[CORRELATION_ID]) {
             ctx[CORRELATION_ID] = context.awsRequestId;
         }
-        sdkLogger.logger.setHapnContext(ctx);
+        logger.setHapnContext(ctx);
     };
     return {
         before,
     };
 };
-const contextualLoggerMiddleware = contextualLogger();
 
-const ioLoggerMiddleware = inputOutputLogger({
+const ioLogger = ({ logger }) => inputOutputLogger({
     omitPaths: [
         'event.multiValueHeaders',
         'event.multiValueQueryStringParameters',
@@ -487,8 +158,11 @@ const ioLoggerMiddleware = inputOutputLogger({
         'response.headers',
     ],
     logger: (req) => {
+        if (isLocal() || isTest()) {
+            return;
+        }
         const message = req?.event ? 'event' : 'response';
-        sdkLogger.logger.info(req.event ?? req.response, message);
+        logger.info(req.event ?? req.response, message);
     },
 });
 
@@ -502,7 +176,7 @@ const normalizerMiddleware = () => {
     };
 };
 
-const offlineAuthMiddleware = ({ authFunctionName = 'spytec-web-api-auth-prod-AuthorizerFunction', enabled = !!process.env.IS_OFFLINE, } = {}) => {
+const offlineAuth = ({ authFunctionName = 'spytec-web-api-auth-prod-AuthorizerFunction', enabled = isOffline(), logger, }) => {
     const lambdaClient = new clientLambda.LambdaClient({ region: process.env.AWS_REGION });
     return {
         before: async (request) => {
@@ -514,7 +188,7 @@ const offlineAuthMiddleware = ({ authFunctionName = 'spytec-web-api-auth-prod-Au
             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
-                sdkLogger.logger.warn('Authorization header is missing or invalid, skipping fake offline authorization');
+                logger.warn('Authorization header is missing or invalid, skipping fake offline authorization');
                 return;
             }
             const token = authHeader.slice(7); // Remove 'Bearer ' prefix
@@ -529,21 +203,44 @@ const offlineAuthMiddleware = ({ authFunctionName = 'spytec-web-api-auth-prod-Au
             });
             try {
                 const response = await lambdaClient.send(command);
-                const responsePayload = JSON.parse(Buffer.from(response.Payload).toString());
+                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);
+                logger.error(error, 'Error invoking auth function');
                 throw new Error('Authorization failed');
             }
         },
     };
 };
 
-const responseWrapperMiddleware = () => {
+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);
     };
@@ -551,7 +248,7 @@ const responseWrapperMiddleware = () => {
         const statusCode = req.error?.code ?? 500;
         const errorMessage = req.error?.message || 'Error';
         const loggerMethod = statusCode >= 500 ? 'error' : 'info';
-        sdkLogger.logger[loggerMethod](req.error, 'Request failed');
+        logger[loggerMethod](req.error, 'Request failed');
         req.response = buildProxyResult({
             statusCode,
             message: errorMessage,
@@ -563,7 +260,7 @@ const responseWrapperMiddleware = () => {
     };
 };
 
-const validatorMiddleware = ({ schema, allowUnknown = true }) => {
+const validator = ({ schema, allowUnknown = true, logger }) => {
     const validatorMiddlewareBefore = (request) => {
         const { error, value } = schema.validate(request.event, {
             allowUnknown,
@@ -575,7 +272,7 @@ const validatorMiddleware = ({ schema, allowUnknown = true }) => {
             },
         });
         if (error) {
-            sdkLogger.logger.error({ error }, 'Validation error');
+            logger.warn(error, 'Validation error');
             throw error.isJoi ? new BadRequestError(error.message) : error;
         }
         request.event = value;
@@ -601,12 +298,14 @@ const warmupMiddleware = (opt = {}) => {
     };
 };
 
-const baseMiddlewares = [
+// Function that returns base middlewares with required logger
+const getBaseMiddlewares = ({ logger }) => [
     warmupMiddleware(),
-    contextualLoggerMiddleware,
-    !(isLocal() || isTest()) ? ioLoggerMiddleware : undefined,
-].filter(Boolean);
-const apiGatewayMiddlewares = [
+    contextualLogger({ logger }),
+    ioLogger({ logger }),
+];
+// Function that returns API Gateway middlewares with required logger
+const getApiGatewayMiddlewares = ({ logger }) => [
     httpResponseSerializer({
         serializers: [
             {
@@ -624,12 +323,10 @@ const apiGatewayMiddlewares = [
         ],
         default: 'application/json',
     }),
-    responseWrapperMiddleware(),
-    offlineAuthMiddleware(),
+    responseWrapper({ logger }),
+    offlineAuth({ logger }),
     normalizerMiddleware(),
 ];
-const middy = (handler) => rawMiddy(handler).use([...baseMiddlewares]);
-const apiGatewayMiddy = (handler) => rawMiddy(handler).use([...baseMiddlewares, ...apiGatewayMiddlewares]);
 
 class LambdaCache {
     collectionName;
@@ -708,10 +405,215 @@ const promiseWithTimeout = (promise, ms, timeoutError = new Error('Promise timed
     //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.merge = merge;
 exports.BadRequestError = BadRequestError;
 exports.BaseError = BaseError;
 exports.ConflictError = ConflictError;
@@ -721,33 +623,31 @@ 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.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.middy = middy;
+exports.offlineAuth = offlineAuth;
 exports.promiseWithCache = promiseWithCache;
 exports.promiseWithTimeout = promiseWithTimeout;
 exports.requestContextValidator = requestContextValidator;
+exports.responseWrapper = responseWrapper;
 exports.setupEnvConfig = setupEnvConfig;
-exports.sqsEventWrapper = sqsEventWrapper$1;
-exports.sqsEventWrapperWithReturn = sqsEventWrapper;
 exports.urlEncoded = urlEncoded;
 exports.validateEvent = validateEvent;
-exports.validatorMiddleware = validatorMiddleware;
+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/middleware/http/response.d.ts

@@ -0,0 +1,8 @@
+import { APIGatewayProxyResult } from 'aws-lambda';
+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, multiValueHeaders, rawResult, stringifyBody, }: HandlerResponse<R>) => APIGatewayProxyResult;

package/dist/middleware/index.d.ts

@@ -1,25 +1,32 @@
-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;
+}
+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 }: 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/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/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.3.28",
+  "version": "3.0.0",
   "description": "Lambda Utils",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -39,7 +39,7 @@
     "qs": "^6.10.1"
   },
   "peerDependencies": {
-    "@spytecgps/sdk-logger": "^2.0.8"
+    "@spytecgps/sdk-logger": "^2.0.18"
   },
   "devDependencies": {
     "@aws-sdk/client-lambda": "^3.731.1",
@@ -48,7 +48,7 @@
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.1.2",
-    "@spytecgps/sdk-logger": "^2.0.8",
+    "@spytecgps/sdk-logger": "^2.0.18",
     "@types/aws-lambda": "^8.10.76",
     "@types/jest": "^29.5.12",
     "@types/joi": "^17.2.3",