Lambda SDP認定企業が、モダンなLambdaハンドラーの実装方法を解説😎middyを使いこなしてLambdaハンドラーを拡張しやすくしましょう

import middy from '@middy/core' // esm Node v14+
import jsonBodyParser from '@middy/http-json-body-parser'
import httpErrorHandler from '@middy/http-error-handler'
import validator from '@middy/validator'
import { transpileSchema } from '@middy/validator/transpile'

const lambdaHandler = async (event, context) => {
  const { creditCardNumber, expiryMonth, expiryYear, cvc, nameOnCard, amount } =
    event.body
  const response = { result: 'success', message: 'payment processed correctly' }
  return { statusCode: 200, body: JSON.stringify(response) }
}

const schema = {
  type: 'object',
  properties: {
    body: {
      type: 'object',
      properties: {
        creditCardNumber: {
          type: 'string',
          minLength: 12,
          maxLength: 19,
          pattern: '\\d+'
        },
        expiryMonth: { type: 'integer', minimum: 1, maximum: 12 },
        expiryYear: { type: 'integer', minimum: 2017, maximum: 2027 },
        cvc: { type: 'string', minLength: 3, maxLength: 4, pattern: '\\d+' },
        nameOnCard: { type: 'string' },
        amount: { type: 'number' }
      },
      required: ['creditCardNumber'] // Insert here all required event properties
    }
  }
}

export const handler = middy()
  .use(jsonBodyParser()) // parses the request body when it's a JSON and converts it to an object
  .use(validator({ eventSchema: transpileSchema(schema) })) // validates the input
  .use(httpErrorHandler()) // handles common http errors and returns proper responses
  .handler(lambdaHandler)

const cacheMiddleware = (options) => {
  let cacheKey

  const cacheMiddlewareBefore = async (request) => {
    cacheKey = options.calculateCacheId(request.event)
    if (options.storage.hasOwnProperty(cacheKey)) {
      // exits early and returns the value from the cache if it's already there
      return options.storage[cacheKey]
    }
  }

  const cacheMiddlewareAfter = async (request) => {
    // stores the calculated response in the cache
    options.storage[cacheKey] = request.response
  }

  return {
    before: cacheMiddlewareBefore,
    after: cacheMiddlewareAfter
  }
}

import middy from '@middy/core';
import { AppSyncAuthorizerEvent, AppSyncResolverEvent, Context } from 'aws-lambda';
import Bugsnag from '@bugsnag/js';
import logger from 'utils/logger';

const STAGE = process.env.STAGE as string;
const useBugsnag = STAGE === 'stg' || STAGE === 'prd';

export default (): middy.MiddlewareObj<AppSyncAuthorizerEvent | AppSyncResolverEvent<unknown>, unknown, Error, Context> => {
  return {
    before: (e): void => {
      if (useBugsnag) {
        Bugsnag.start({
          apiKey: process.env.BUGSNAG_API_KEY as string,
          releaseStage: process.env.STAGE as string,
          sendCode: false,
          trackInlineScripts: false,
          context: e.context?.functionName,
          metadata: {
            region: process.env.REGION as string,
            function_name: e.context?.functionName,
            function_version: e.context?.functionVersion,
          },
        });
      }
    },
    onError: (request): void => {
      logger.error('request : ', {
        request: { ...request },
      });
      if (useBugsnag) {
        Bugsnag.notify(request);
      }
    },
  };
};

export const handler = middy()
  .use(jsonBodyParser()) // parses the request body when it's a JSON and converts it to an object
  .use(validator({ eventSchema: transpileSchema(schema) })) // validates the input
  .use(httpErrorHandler()) // handles common http errors and returns proper responses
  .handler(lambdaHandler)