aws-lambda#APIGatewayProxyEvent TypeScript Examples

handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  const S = event.queryStringParameters?.state || '';
  const key = {
    TableName: "RoamJSAuth",
    Key: { id: { S } },
  };
  return dynamo
    .getItem(key)
    .promise()
    .then((r) => {
      if (r.Item) {
        if (isAfter(new Date(), addMinutes(new Date(r.Item.date.S), 10))) {
          return dynamo
            .deleteItem(key)
            .promise()
            .then(() => bareSuccessResponse(event));
        } else {
          return {
            statusCode: 200,
            body: JSON.stringify({ success: false }),
            headers: headers(event),
          };
        }
      } else {
        return bareSuccessResponse(event);
      }
    })
    .catch((e) => ({
      statusCode: 500,
      body: e.message,
      headers: headers(event),
    }));
}

getTagOrganizations = async (
  event: APIGatewayProxyEvent,
  id: string
): Promise<string[]> => {
  if (!isGlobalViewAdmin(event)) return [];
  const tag = await OrganizationTag.findOne(
    { id },
    { relations: ['organizations'] }
  );
  if (tag) return tag?.organizations.map((org) => org.id);
  return [];
}

listHandler = async (event: APIGatewayProxyEvent, context: Context): Promise<APIGatewayProxyResult> => {
  initApplication();

  try {
    _applicationContainer.logger.debug('Role List Handler Event: %o', event);

    const roleListDto = Object.assign(new RoleListDto(), event.queryStringParameters) as RoleListDto;
    await validateOrReject(plainToClass(RoleListDto, roleListDto));

    const repository = _applicationContainer.get<ProjectionRepository<RoleProjection>>(DynamoProjectionRepository);
    const roleProjections = await repository.list(process.env.projectionRolesTable, roleListDto);

    return { statusCode: HttpStatus.OK, body: JSON.stringify(roleProjections) };
  } catch (error) {
    return ApplicationController.handleError(_applicationContainer, error);
  }
}

beforeEach(() => {
  /** Create a mock event body */
  mockEvent = ({
    body: JSON.stringify({
      firstName: `John`,
      lastName: `Doe`,
      email: `[email protected]`,
      password: `Abcd1234`,
    }),
  } as unknown) as APIGatewayProxyEvent;
});

handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  const { service, otp, auth } = JSON.parse(event.body);
  return dynamo
    .putItem({
      TableName: "RoamJSAuth",
      Item: {
        id: { S: `${service}_${otp}` },
        auth: { S: auth },
        date: { S: new Date().toJSON() },
      },
    })
    .promise()
    .then(() => emptyResponse(event));
}

handler = (
  event: APIGatewayProxyEvent,
  context: Context,
  cb: Callback
) => {
  context.callbackWaitsForEmptyEventLoop = false;
  app.ready((e) => {
    if (e) return console.error(e.stack || e);
    awsServerlessExpress.proxy(server, event, context, "CALLBACK", cb);
  });
}

main: APIGatewayProxyHandler = async (event: APIGatewayProxyEvent) => {
    const { username, photoId } = event.pathParameters
    const photo = await getPhoto(username, photoId)
    const response = {
        statusCode: 200,
        body: JSON.stringify({
            photo
        })
    }

    return response
}

deleteController = async (
  event: APIGatewayProxyEvent,
  documentClient: DynamoDB.DocumentClient
) => {
  let item = {
    id: event.queryStringParameters.id,
    status: event.queryStringParameters.status,
    date_added: event.queryStringParameters.date_added,
  }
  
  const params = ThingModel.delete(item)
  const response = await documentClient.delete(params).promise()
  
  return ThingModel.parse(response);
}

export function constructAPIGwEvent(message: any, options: Record<string, any> = {}): APIGatewayProxyEvent {
  return {
    httpMethod: options.method || 'GET',
    path: options.path || '/',
    queryStringParameters: options.query || {},
    headers: options.headers || {},
    body: options.rawBody || JSON.stringify(message),
    multiValueHeaders: {},
    multiValueQueryStringParameters: {},
    isBase64Encoded: false,
    pathParameters: options.pathParameters || {},
    stageVariables: options.stageVariables || {},
    requestContext: options.requestContext || {},
    resource: options.resource || '',
  }
}

putItemHandler = async (
    event: APIGatewayProxyEvent,
): Promise<APIGatewayProxyResult> => {
    if (event.httpMethod !== 'POST') {
        throw new Error(`postMethod only accepts POST method, you tried: ${event.httpMethod} method.`);
    }
    // All log statements are written to CloudWatch
    console.info('received:', event);

    // Get id and name from the body of the request
    const body = JSON.parse(event.body)
    const id = body.id;
    const name = body.name;

    const client = new CustomSqsClient();
    const result = await client.send({ id, name });

    const response = {
        statusCode: 201,
        body: JSON.stringify({ MessageId: result.MessageId })
    };

    // All log statements are written to CloudWatch
    console.info(`response from: ${event.path} statusCode: ${response.statusCode} body: ${response.body}`);
    return response;
}

getController = async (
  event: APIGatewayProxyEvent,
  documentClient: DynamoDB.DocumentClient
) => {
  let item = {
    id: event.queryStringParameters.id,
    status: event.queryStringParameters.status,
    date_added: event.queryStringParameters.date_added,
  }
  
  const params = ThingModel.get(item)
  const response = await documentClient.get(params).promise()
  
  return ThingModel.parse(response);
}

getByIdHandler = async (
  event: APIGatewayProxyEvent,
): Promise<APIGatewayProxyResult> => {
  if (event.httpMethod !== 'GET') {
    throw new Error(`getMethod only accept GET method, you tried: ${event.httpMethod}`);
  }
  // All log statements are written to CloudWatch
  console.info('received:', event);
 
  // Get id from pathParameters from APIGateway because of `/{id}` at template.yml
  const id = event.pathParameters.id;
 
  const client = new CustomDynamoClient();
  const item = await client.read(id);

  const response = {
    statusCode: 200,
    body: JSON.stringify(item)
  };
 
  // All log statements are written to CloudWatch
  console.info(`response from: ${event.path} statusCode: ${response.statusCode} body: ${response.body}`);
  return response;
}

exampleHandler = async (
  event: APIGatewayProxyEvent,
): Promise<APIGatewayProxyResult> => {
  // All log statements are written to CloudWatch
  console.debug('Received event:', event);

  return {
    statusCode: 200,
    body: JSON.stringify({
      message: 'Hello world!',
    })
  };
}

createController = async (
  event: APIGatewayProxyEvent,
  documentClient: DynamoDB.DocumentClient
) => {
  // Parse string to verified request schema model
  const input: Thing = JSON.parse(event.body);
  const item = {
    id: uuid(),
    status: input.status || 'OK',
    date_added: (+new Date()).toString(),
    name: input.name,
  };
  const params = ThingModel.put(item);

  await documentClient.put(params).promise();

  return item;
}

main: APIGatewayProxyHandler = async (event: APIGatewayProxyEvent) => {
    const { username, photoId } = event.pathParameters
    const photo = new Photo(username, "", photoId)
    const { commentingUsername, content } = JSON.parse(event.body)
    const comment = await commentOnPhoto(photo, commentingUsername, content)
    const response = {
        statusCode: 200,
        body: JSON.stringify({
            comment
        })
    }

    return response
}

APIGatewayProxyEventSample: APIGatewayProxyEvent = {
  body: ``,
  headers: {},
  httpMethod: "POST",
  isBase64Encoded: false,
  path: "/",
  queryStringParameters: {},
  pathParameters: {},
  stageVariables: {},
  multiValueHeaders: {},
  requestContext: null,
  resource: "/",
  multiValueQueryStringParameters: {}
}

export function constructAPIGwEvent(message: any, options: any = DEFAULT_OPTIONS): APIGatewayProxyEvent {
  const opts = Object.assign({}, DEFAULT_OPTIONS, options);
  return {
    httpMethod: opts.method,
    path: opts.path,
    queryStringParameters: opts.query,
    headers: opts.headers,
    body: opts.rawBody || JSON.stringify(message),
    multiValueHeaders: {},
    multiValueQueryStringParameters: {},
    isBase64Encoded: false,
    pathParameters: opts.pathParameters || {},
    stageVariables: {},
    requestContext: null,
    resource: null,
  }
}

isOrgAdmin = (
  event: APIGatewayProxyEvent,
  organizationId?: string
) => {
  if (!organizationId || !event.requestContext.authorizer) return false;
  for (const role of event.requestContext.authorizer.roles) {
    if (role.org === organizationId && role.role === 'admin') return true;
  }
  return isGlobalWriteAdmin(event);
}

handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> =>
  getClerkUser(event).then(async (user) => {
    if (!user) {
      return {
        statusCode: 401,
        body: "No Active Session",
        headers: headers(event),
      };
    }
    const customer = user.privateMetadata?.stripeId as string;
    const subs = await stripe.subscriptions
      .list({
        customer,
      })
      .then((r) =>
        Promise.all(
          r.data.map((s) =>
            stripe.invoices
              .retrieveUpcoming({ subscription: s.id })
              .then((i) => ({
                invoiceAmountsByPrice: Object.fromEntries(
                  i.lines.data.map((l) => [l.price.id, l.amount])
                ),
                items: s.items,
                date: i.period_end * 1000,
              }))
          )
        )
      );
    const productIds = subs.flatMap((s) =>
      s.items.data.map((i) => i.price.product as string)
    );
    return stripe.products
      .list({ ids: productIds })
      .then((products) =>
        Object.fromEntries(
          products.data.map(({ id, name, description }) => [
            id,
            { name, description },
          ])
        )
      )
      .then((productMap) =>
        subs.flatMap((s) => {
          return s.items.data.map((i) => ({
            ...productMap[i.price.product as string],
            id: i.id,
            amount: s.invoiceAmountsByPrice[i.price.id] / 100,
            date: s.date,
          }));
        })
      )
      .then((subscriptions) => ({
        statusCode: 200,
        body: JSON.stringify({
          subscriptions,
        }),
        headers: headers(event),
      }))
      .catch((e) => ({
        statusCode: 500,
        body: e.message,
        headers: headers(event),
      }));
  })

filterCurrentAuctions = async (
  event: APIGatewayProxyEvent,
): Promise<APIGatewayProxyResult> => {
  if (!event.body) {
    return {
      statusCode: 400,
      headers: {
        'Content-Type': 'application/json',
        'Access-Control-Allow-Origin': '*',
        'Access-Control-Allow-Headers': '*',
        'Access-Control-Allow-Credentials': true,
      },
      body: JSON.stringify({ error: 'empty body' }),
    }
  }

  const currentAuctions = filterOldAuctions(auctions)

  const serializedBody: SerializedFilterBody = JSON.parse(event.body as string)
  const { filterOptions, sortOptions, paginationOptions } =
    deserializeBody(serializedBody)

  const filteredAuctions = filterCharacters({
    auctions: currentAuctions,
    filters: filterOptions,
  })

  const sortedAuctions = applySort(filteredAuctions, sortOptions)

  const paginatedData = paginateData(sortedAuctions, paginationOptions)

  const responseBody = {
    ...paginatedData,
    ...sortOptions,
  }

  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*',
      'Access-Control-Allow-Headers': '*',
      'Access-Control-Allow-Credentials': true,
    },
    body: JSON.stringify(responseBody),
  }
}

userError = (
  body: string,
  event: APIGatewayProxyEvent
): APIGatewayProxyResult => ({
  statusCode: 400,
  body,
  headers: headers(event),
})

mockEvent: APIGatewayProxyEvent

getOrgMemberships = (event: APIGatewayProxyEvent): string[] => {
  if (!event.requestContext.authorizer) return [];
  return event.requestContext.authorizer.roles.map((role) => role.org);
}

handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> =>
  getClerkUser(event).then((user) => {
    if (!user) {
      return {
        statusCode: 401,
        body: "No Active Session",
        headers: headers(event),
      };
    }
    const customer = user?.privateMetadata?.stripeId as string;
    const { id } = JSON.parse(event.body || "{}");
    if (!id) {
      return {
        statusCode: 400,
        body: "id is required",
        headers: headers(event),
      };
    }

    return stripe.paymentMethods.retrieve(id).then((pm) => {
      if (!pm.customer) {
        return {
          statusCode: 400,
          body: "No customer attached to payment method",
          headers: headers(event),
        };
      }
      if (pm.customer !== customer) {
        return {
          statusCode: 400,
          body: "Payment method not attached to the current user",
          headers: headers(event),
        };
      }
      return stripe.customers
        .update(pm.customer as string, {
          invoice_settings: {
            default_payment_method: pm.id,
          },
        })
        .then(() => ({
          statusCode: 200,
          body: JSON.stringify({ success: true }),
          headers: headers(event),
        }));
    });
  })

isGlobalWriteAdmin = (event: APIGatewayProxyEvent) => {
  return event.requestContext.authorizer &&
    event.requestContext.authorizer.userType === UserType.GLOBAL_ADMIN
    ? true
    : false;
}

handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  const user = await getClerkUser(event);
  if (!user) {
    return {
      statusCode: 401,
      body: "No Active Session",
      headers: headers(event),
    };
  }
  const { service = '', extension = service, quantity = 1 } = JSON.parse(event.body || "{}") as {
    extension?: string;
    service?: string;
    quantity?: number;
  };
  const extensionField = extension
    .split("-")
    .map((s, i) =>
      i == 0 ? s : `${s.substring(0, 1).toUpperCase()}${s.substring(1)}`
    )
    .join("");
  const priceId = await getStripePriceId(extension);
  const customer = user.privateMetadata?.stripeId as string;
  const usage = await stripe.prices
    .retrieve(priceId)
    .then((p) => p.recurring?.usage_type);
  const line_items = [
    usage === "metered"
      ? { price: priceId }
      : { price: priceId, quantity },
  ];
  const finishSubscription = () =>
    users
      .updateUser(user.id, {
        publicMetadata: {
          ...user.publicMetadata,
          [extensionField]: {},
        },
      })
      .then(() => ({
        statusCode: 200,
        body: JSON.stringify({ success: true }),
        headers: headers(event),
      }));

  const roamjsSubscription = await stripe.subscriptions
    .list({ customer })
    .then((all) => all.data.find((s) => s.metadata.project === "RoamJS"));
  if (roamjsSubscription) {
    return stripe.subscriptionItems
      .create({
        subscription: roamjsSubscription.id,
        ...line_items[0],
      })
      .then(finishSubscription);
  }

  const paymentMethod = await stripe.customers
    .retrieve(customer)
    .then((c) => c as Stripe.Customer)
    .then((c) => c.invoice_settings?.default_payment_method);
  const origin = event.headers.Origin || event.headers.origin;

  const { active, id, error } = paymentMethod
    ? await stripe.subscriptions
        .create({
          customer,
          items: line_items,
          metadata: {
            project: "RoamJS",
          },
        })
        .then((s) => ({ active: true, id: s.id, error: undefined }))
        .catch((error) => ({ active: false, id: undefined, error }))
    : await stripe.checkout.sessions
        .create({
          customer,
          payment_method_types: ["card"],
          line_items,
          mode: "subscription",
          success_url: `${origin}/extensions/${extension}?success=true`,
          cancel_url: `${origin}/extensions/${extension}?cancel=true`,
          subscription_data: {
            metadata: {
              project: "RoamJS",
            },
          },
          metadata: {
            extension: extensionField,
            userId: user.id,
            callback: `${process.env.API_URL}/finish-start-service`,
          },
        })
        .then((session) => ({ id: session.id, active: false, error: undefined }))
        .catch((error) => ({ active: false, id: undefined, error }));

  if (!active) {
    if (id) {
      return {
        statusCode: 200,
        body: JSON.stringify({ sessionId: id }),
        headers: headers(event),
      };
    } else {
      console.log(error);
      return {
        statusCode: 500,
        body: "Failed to subscribe to RoamJS extension. Contact [email protected] for help!",
        headers: headers(event),
      };
    }
  }

  return finishSubscription();
}