@energica-city/shared-amplify-utils
Version:
Shared utilities for AWS Amplify projects
186 lines • 25.3 kB
JavaScript
import { logger } from '../../log';
import * as yup from 'yup';
import { buildRestContext, parseJsonBody, createValidationError, getRequestId, } from './utils';
/** Symbol key for storing validated request body data */
const VALIDATED_BODY_KEY = Symbol('validatedBody');
/** Symbol key for storing validated query parameters */
const VALIDATED_QUERY_KEY = Symbol('validatedQuery');
/** Symbol key for storing validated path parameters */
const VALIDATED_PATH_KEY = Symbol('validatedPath');
/** Symbol key for storing validated headers */
const VALIDATED_HEADERS_KEY = Symbol('validatedHeaders');
export { VALIDATED_BODY_KEY, VALIDATED_QUERY_KEY, VALIDATED_PATH_KEY, VALIDATED_HEADERS_KEY, };
/**
* Retrieves validated request body from middleware chain
* @param input - REST input with validation data storage
* @returns Validated and typed request body
*
* @example
* ```typescript
* const userData = getValidatedBody<UserCreateInput>(input);
* console.log(userData.name); // Type-safe access
* ```
*/
export function getValidatedBody(input) {
const validatedData = input.event;
return validatedData[VALIDATED_BODY_KEY];
}
/**
* Retrieves validated query parameters from middleware chain
* @param input - REST input with validation data storage
* @returns Validated and typed query parameters
*
* @example
* ```typescript
* const queryParams = getValidatedQuery<{ page: number; limit: number }>(input);
* ```
*/
export function getValidatedQuery(input) {
const validatedData = input.event;
return validatedData[VALIDATED_QUERY_KEY];
}
/**
* Retrieves validated path parameters from middleware chain
* @param input - REST input with validation data storage
* @returns Validated and typed path parameters
*/
export function getValidatedPath(input) {
const validatedData = input.event;
return validatedData[VALIDATED_PATH_KEY];
}
/**
* Retrieves validated headers from middleware chain
* @param input - REST input with validation data storage
* @returns Validated and typed headers
*/
export function getValidatedHeaders(input) {
const validatedData = input.event;
return validatedData[VALIDATED_HEADERS_KEY];
}
/**
* Stores validated data in the event object using symbol keys
* @param input - REST input with validation data storage
* @param key - Symbol key for data storage
* @param data - Validated data to store
*/
function storeValidatedData(input, key, data) {
const validatedData = input.event;
validatedData[key] = data;
}
/**
* Validates data against a Yup schema with standardized error handling
* @param schema - Yup validation schema
* @param data - Data to validate
* @param fieldName - Name of the field being validated (for error messages)
* @param input - REST input for error context
* @returns Validated data conforming to schema type
* @throws ValidationError with REST context if validation fails
*/
async function validateSchema(schema, data, fieldName, input) {
try {
return await schema.validate(data, { abortEarly: false });
}
catch (error) {
if (error instanceof yup.ValidationError) {
throw createValidationError({
message: `Validation failed for ${fieldName}: ${error.errors.join(', ')}`,
event: input.event,
errorCode: 'VALIDATION_ERROR',
statusCode: 400,
additionalContext: {
field: fieldName,
errors: error.errors,
},
});
}
throw error;
}
}
/**
* Creates REST request validator middleware with parallel validation
*
* Validates request components (body, query, path, headers) in parallel for optimal performance.
* Stores validated data using symbol keys for type-safe retrieval in handlers.
*
* @param validationConfig - Configuration specifying which parts to validate
* @returns Middleware function that validates requests and stores results
*
* @example
* ```typescript
* const validator = createRestRequestValidator({
* body: yup.object({
* name: yup.string().required(),
* email: yup.string().email().required()
* }),
* headers: yup.object({
* authorization: yup.string().required()
* })
* });
*
* chain.use('validator', validator);
* ```
*/
export function createRestRequestValidator(validationConfig) {
const { body: bodySchema, query: querySchema, path: pathSchema, headers: headersSchema, } = validationConfig;
return async (input, next) => {
const typedInput = input;
const { event } = typedInput;
const requestId = getRequestId(event, input.context);
const logContext = buildRestContext(typedInput, {
requestId,
});
const validationTasks = [];
if (bodySchema) {
const bodyValidation = (async () => {
const body = parseJsonBody(event.body ?? undefined, logContext);
const validatedBody = await validateSchema(bodySchema, body, 'body', typedInput);
storeValidatedData(typedInput, VALIDATED_BODY_KEY, validatedBody);
})();
validationTasks.push(bodyValidation);
}
if (querySchema) {
const queryValidation = (async () => {
const validatedQuery = await validateSchema(querySchema, event.queryStringParameters || {}, 'query', typedInput);
storeValidatedData(typedInput, VALIDATED_QUERY_KEY, validatedQuery);
})();
validationTasks.push(queryValidation);
}
if (pathSchema) {
const pathValidation = (async () => {
const validatedPath = await validateSchema(pathSchema, event.pathParameters || {}, 'path', typedInput);
storeValidatedData(typedInput, VALIDATED_PATH_KEY, validatedPath);
})();
validationTasks.push(pathValidation);
}
if (headersSchema) {
const headersValidation = (async () => {
const validatedHeaders = await validateSchema(headersSchema, event.headers || {}, 'headers', typedInput);
storeValidatedData(typedInput, VALIDATED_HEADERS_KEY, validatedHeaders);
})();
validationTasks.push(headersValidation);
}
if (validationTasks.length > 0) {
try {
await Promise.all(validationTasks);
logger.debug('Request validation completed', buildRestContext(typedInput, {
requestId,
validatedFields: [
bodySchema ? 'body' : null,
querySchema ? 'query' : null,
pathSchema ? 'path' : null,
headersSchema ? 'headers' : null,
].filter(Boolean),
}));
}
catch (error) {
logger.error('Request validation failed', buildRestContext(typedInput, {
requestId,
error: error instanceof Error ? error.message : 'Unknown error',
}));
throw error;
}
}
return next(typedInput);
};
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RestRequestValidator.js","sourceRoot":"","sources":["../../../middleware/rest/RestRequestValidator.ts"],"names":[],"mappings":"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","sourcesContent":["import { logger } from '../../log';\nimport * as yup from 'yup';\nimport type { Middleware } from '../middlewareChain';\nimport type {\n  RestResponse,\n  RestInputWithModels,\n  RestInputWithValidation,\n  RestRequestValidationConfig,\n  ValidatedDataStorage,\n} from './types';\nimport type { AmplifyModelType } from '../../queries/types';\nimport {\n  buildRestContext,\n  parseJsonBody,\n  createValidationError,\n  getRequestId,\n} from './utils';\n\n/** Symbol key for storing validated request body data */\nconst VALIDATED_BODY_KEY = Symbol('validatedBody');\n/** Symbol key for storing validated query parameters */\nconst VALIDATED_QUERY_KEY = Symbol('validatedQuery');\n/** Symbol key for storing validated path parameters */\nconst VALIDATED_PATH_KEY = Symbol('validatedPath');\n/** Symbol key for storing validated headers */\nconst VALIDATED_HEADERS_KEY = Symbol('validatedHeaders');\n\nexport {\n  VALIDATED_BODY_KEY,\n  VALIDATED_QUERY_KEY,\n  VALIDATED_PATH_KEY,\n  VALIDATED_HEADERS_KEY,\n};\n\n/**\n * Retrieves validated request body from middleware chain\n * @param input - REST input with validation data storage\n * @returns Validated and typed request body\n *\n * @example\n * ```typescript\n * const userData = getValidatedBody<UserCreateInput>(input);\n * console.log(userData.name); // Type-safe access\n * ```\n */\nexport function getValidatedBody<\n  T = unknown,\n  TTypes extends Record<string, AmplifyModelType> = Record<\n    string,\n    AmplifyModelType\n  >,\n>(input: RestInputWithValidation<TTypes>): T {\n  const validatedData = input.event as ValidatedDataStorage;\n  return validatedData[VALIDATED_BODY_KEY] as T;\n}\n\n/**\n * Retrieves validated query parameters from middleware chain\n * @param input - REST input with validation data storage\n * @returns Validated and typed query parameters\n *\n * @example\n * ```typescript\n * const queryParams = getValidatedQuery<{ page: number; limit: number }>(input);\n * ```\n */\nexport function getValidatedQuery<\n  T = Record<string, unknown>,\n  TTypes extends Record<string, AmplifyModelType> = Record<\n    string,\n    AmplifyModelType\n  >,\n>(input: RestInputWithValidation<TTypes>): T {\n  const validatedData = input.event as ValidatedDataStorage;\n  return validatedData[VALIDATED_QUERY_KEY] as T;\n}\n\n/**\n * Retrieves validated path parameters from middleware chain\n * @param input - REST input with validation data storage\n * @returns Validated and typed path parameters\n */\nexport function getValidatedPath<\n  T = Record<string, unknown>,\n  TTypes extends Record<string, AmplifyModelType> = Record<\n    string,\n    AmplifyModelType\n  >,\n>(input: RestInputWithValidation<TTypes>): T {\n  const validatedData = input.event as ValidatedDataStorage;\n  return validatedData[VALIDATED_PATH_KEY] as T;\n}\n\n/**\n * Retrieves validated headers from middleware chain\n * @param input - REST input with validation data storage\n * @returns Validated and typed headers\n */\nexport function getValidatedHeaders<\n  T = Record<string, unknown>,\n  TTypes extends Record<string, AmplifyModelType> = Record<\n    string,\n    AmplifyModelType\n  >,\n>(input: RestInputWithValidation<TTypes>): T {\n  const validatedData = input.event as ValidatedDataStorage;\n  return validatedData[VALIDATED_HEADERS_KEY] as T;\n}\n\n/**\n * Stores validated data in the event object using symbol keys\n * @param input - REST input with validation data storage\n * @param key - Symbol key for data storage\n * @param data - Validated data to store\n */\nfunction storeValidatedData<\n  TTypes extends Record<string, AmplifyModelType> = Record<\n    string,\n    AmplifyModelType\n  >,\n>(input: RestInputWithValidation<TTypes>, key: symbol, data: unknown): void {\n  const validatedData = input.event as ValidatedDataStorage;\n  validatedData[key] = data;\n}\n\n/**\n * Validates data against a Yup schema with standardized error handling\n * @param schema - Yup validation schema\n * @param data - Data to validate\n * @param fieldName - Name of the field being validated (for error messages)\n * @param input - REST input for error context\n * @returns Validated data conforming to schema type\n * @throws ValidationError with REST context if validation fails\n */\nasync function validateSchema<\n  T,\n  TTypes extends Record<string, AmplifyModelType> = Record<\n    string,\n    AmplifyModelType\n  >,\n>(\n  schema: yup.Schema<T>,\n  data: unknown,\n  fieldName: string,\n  input: RestInputWithValidation<TTypes>,\n): Promise<T> {\n  try {\n    return await schema.validate(data, { abortEarly: false });\n  } catch (error) {\n    if (error instanceof yup.ValidationError) {\n      throw createValidationError({\n        message: `Validation failed for ${fieldName}: ${error.errors.join(', ')}`,\n        event: input.event,\n        errorCode: 'VALIDATION_ERROR',\n        statusCode: 400,\n        additionalContext: {\n          field: fieldName,\n          errors: error.errors,\n        },\n      });\n    }\n    throw error;\n  }\n}\n\n/**\n * Creates REST request validator middleware with parallel validation\n *\n * Validates request components (body, query, path, headers) in parallel for optimal performance.\n * Stores validated data using symbol keys for type-safe retrieval in handlers.\n *\n * @param validationConfig - Configuration specifying which parts to validate\n * @returns Middleware function that validates requests and stores results\n *\n * @example\n * ```typescript\n * const validator = createRestRequestValidator({\n *   body: yup.object({\n *     name: yup.string().required(),\n *     email: yup.string().email().required()\n *   }),\n *   headers: yup.object({\n *     authorization: yup.string().required()\n *   })\n * });\n *\n * chain.use('validator', validator);\n * ```\n */\nexport function createRestRequestValidator<\n  TTypes extends Record<string, AmplifyModelType> = Record<\n    string,\n    AmplifyModelType\n  >,\n>(\n  validationConfig: RestRequestValidationConfig,\n): Middleware<RestInputWithModels<TTypes>, RestResponse> {\n  const {\n    body: bodySchema,\n    query: querySchema,\n    path: pathSchema,\n    headers: headersSchema,\n  } = validationConfig;\n\n  return async (input: RestInputWithModels<TTypes>, next) => {\n    const typedInput = input as RestInputWithValidation<TTypes>;\n    const { event } = typedInput;\n\n    const requestId = getRequestId(event, input.context);\n    const logContext = buildRestContext(typedInput as RestInputWithModels, {\n      requestId,\n    });\n\n    const validationTasks: Promise<void>[] = [];\n\n    if (bodySchema) {\n      const bodyValidation = (async () => {\n        const body = parseJsonBody(event.body ?? undefined, logContext);\n        const validatedBody = await validateSchema(\n          bodySchema,\n          body,\n          'body',\n          typedInput,\n        );\n        storeValidatedData(typedInput, VALIDATED_BODY_KEY, validatedBody);\n      })();\n      validationTasks.push(bodyValidation);\n    }\n\n    if (querySchema) {\n      const queryValidation = (async () => {\n        const validatedQuery = await validateSchema(\n          querySchema,\n          event.queryStringParameters || {},\n          'query',\n          typedInput,\n        );\n        storeValidatedData(typedInput, VALIDATED_QUERY_KEY, validatedQuery);\n      })();\n      validationTasks.push(queryValidation);\n    }\n\n    if (pathSchema) {\n      const pathValidation = (async () => {\n        const validatedPath = await validateSchema(\n          pathSchema,\n          event.pathParameters || {},\n          'path',\n          typedInput,\n        );\n        storeValidatedData(typedInput, VALIDATED_PATH_KEY, validatedPath);\n      })();\n      validationTasks.push(pathValidation);\n    }\n\n    if (headersSchema) {\n      const headersValidation = (async () => {\n        const validatedHeaders = await validateSchema(\n          headersSchema,\n          event.headers || {},\n          'headers',\n          typedInput,\n        );\n        storeValidatedData(typedInput, VALIDATED_HEADERS_KEY, validatedHeaders);\n      })();\n      validationTasks.push(headersValidation);\n    }\n\n    if (validationTasks.length > 0) {\n      try {\n        await Promise.all(validationTasks);\n        logger.debug(\n          'Request validation completed',\n          buildRestContext(typedInput as RestInputWithModels, {\n            requestId,\n            validatedFields: [\n              bodySchema ? 'body' : null,\n              querySchema ? 'query' : null,\n              pathSchema ? 'path' : null,\n              headersSchema ? 'headers' : null,\n            ].filter(Boolean),\n          }),\n        );\n      } catch (error) {\n        logger.error(\n          'Request validation failed',\n          buildRestContext(typedInput as RestInputWithModels, {\n            requestId,\n            error: error instanceof Error ? error.message : 'Unknown error',\n          }),\n        );\n        throw error;\n      }\n    }\n\n    return next(typedInput);\n  };\n}\n"]}