How to use the middy function in middy

}
  const note = await updateNoteById(noteId, userId, event.body);
  return callback(null, success(note));
};

export const validator = validateRequestBody({
  noteId: [],
  userId: [],
  content: [required], // TODO: validate slate schema
  title: [required, isString],
  tags: [required, isArray(v => typeof v === "string")],
  dateUpdated: [],
  overwrite: []
});

export const handler = middy(update)
  .use(jsonBodyParser())
  .use(validator)
  .use(encodeResponse())
  .use(jsonErrorHandler())
  .use(cors());

const update: UpdateHandler = async (event, _ctx, callback) => {
  const userId = getUserIdentityId(event);
  try {
    const preferences = await updatePreferencesById(userId, event.body);
    return callback(null, success(preferences));
  } catch (err) {
    if (err instanceof HttpError.NotFound) {
      throw notFound(`Preferences for user ${userId} not found`);
    } else {
      throw exception(err);
    }
  }
};

export const handler = middy(update)
  .use(jsonBodyParser())
  .use(validator)
  .use(encodeResponse())
  .use(jsonErrorHandler())
  .use(cors());

const S3UploadPath = `${title} - ${hash}.md`;
  await S3.upload({
    Bucket: process.env.EXPORT_BUCKET,
    Key: S3UploadPath,
    Body: output,
    ACL: "public-read"
  }).promise();

  const src = `https://s3-${process.env.REGION}.amazonaws.com/${process.env.EXPORT_BUCKET}/${S3UploadPath}`;

  const response: ExportResponseDTO = { src };

  return callback(null, success(response));
};

export const handler = middy(markdown)
  .use(jsonBodyParser())
  .use(validator)
  .use(encodeResponse())
  .use(jsonErrorHandler())
  .use(cors());

import campaignRepository from '../repositories/campaign';
import decryptor from '../lib/auth-token-decryptor';
import { apiRequestRoutine, logRoutine } from '../../common/middlewares';
import { TokenData } from '../types';

export async function action({pathParameters: {id: campaignId}, headers: {Authorization: authToken}}: APIGatewayEvent): Promise {
  const {sub: userId}: TokenData = decryptor(authToken);
  await campaignRepository.delete(userId, campaignId);

  return {
    statusCode: 204,
    body: ''
  };
}

export default middy(action)
  .use(jsonBodyParser())
  .use(apiRequestRoutine())
  .use(logRoutine());

title: [required, isString],
  content: [required]
});

const create: CreateHandler = async (
  event,
  _ctx,
  callback
) => {
  const userId = getUserIdentityId(event);
  const noteId = uuid();
  const note = await createSnippet(noteId, userId, event.body);
  return callback(null, success(note));
};

export const handler = middy(create)
  .use(jsonBodyParser())
  .use(validator)
  .use(encodeResponse())
  .use(jsonErrorHandler())
  .use(cors());

import middy from "middy";
import { httpErrorHandler, cors } from "middy/middlewares";
import { encodeResponse } from "@internote/lib/middlewares";
import { success } from "@internote/lib/responses";
import { getUserIdentityId } from "@internote/lib/user";
import { GetHandler } from "@internote/lib/types";
import { listNotesByUserId } from "./db/queries";

const list: GetHandler = async (event, _ctx, callback) => {
  const userId = getUserIdentityId(event);
  const notes = await listNotesByUserId(userId);
  return callback(null, success(notes));
};

export const handler = middy(list)
  .use(encodeResponse())
  .use(httpErrorHandler())
  .use(cors());

import { getUserIdentityId } from "@internote/lib/user";
import { DeleteHandler } from "@internote/lib/types";
import { deleteNoteById } from "./db/queries";

const del33t: DeleteHandler<{ noteId: string }> = async (
  event,
  _ctx,
  callback
) => {
  const { noteId } = event.pathParameters;
  const userId = getUserIdentityId(event);
  await deleteNoteById(noteId, userId);
  return callback(null, success({}));
};

export const handler = middy(del33t)
  .use(encodeResponse())
  .use(httpErrorHandler())
  .use(cors());