aws-lambda#APIGatewayProxyHandler TypeScript Examples

handler: APIGatewayProxyHandler = async (event) => {
  const { id, limit, page } = event.queryStringParameters || {};
  const limitValue = Number(limit) || 1;
  const pageValue = Number(page) || 0;
  if (limitValue < 1) {
    return userError("Limit must be greater than 0", event);
  }
  if (pageValue < 0) {
    return userError("Page must be greater than or equal to 0", event);
  }
  if (!id) {
    return userError("Must include extension to look up versions", event);
  }
  return s3
    .listObjectsV2({ Bucket: "roamjs.com", Prefix: `${id}/`, Delimiter: "/" })
    .promise()
    .then((r) => {
      const allVersions = r.CommonPrefixes.map((c) => c.Prefix)
        .filter((s) => /\d\d\d\d-\d\d-\d\d-\d\d-\d\d/.test(s))
        .reverse();
      return {
        versions: allVersions
          .slice(pageValue, pageValue + limitValue)
          .map((s) => s.replace(id, "").replace(/\//g, "")),
        isEnd: pageValue + limitValue >= allVersions.length,
      };
    })
    .then((res) => ({
      statusCode: 200,
      body: JSON.stringify(res),
      headers,
    }))
    .catch(emailCatch(`Failed to fetch versions for ${id}`));
}

token: APIGatewayProxyHandler = async (event, _context) => {
  try {
    if (
      event.pathParameters?.id &&
      event.pathParameters?.id.length > 0 &&
      !JSON.stringify(tokenProps[event.pathParameters.id])
    ) {
      throw new Error('Token not found')
    }

    return {
      statusCode: 200,
      body:
        event.pathParameters?.id && event.pathParameters?.id.length > 0
          ? JSON.stringify(tokenProps[event.pathParameters.id])
          : JSON.stringify(tokenProps),
      headers: {
        'Access-Control-Allow-Origin': '*',
      },
    }
  } catch (e) {
    return {
      statusCode: 500,
      body: JSON.stringify(e),
      headers: {
        'Access-Control-Allow-Origin': '*',
      },
    }
  }
}

ethusd: APIGatewayProxyHandler = async (_event, _context) => {
  try {
    const { APIETHERSCAN } = process.env

    const quote = await (
      await fetch(
        `https://api.etherscan.io/api?module=stats&action=ethprice&apikey=${APIETHERSCAN}`
      )
    ).json()

    return {
      statusCode: 200,
      body: JSON.stringify(quote),
      headers: {
        'Access-Control-Allow-Origin': '*',
      },
    }
  } catch (e) {
    console.log(e)

    return {
      statusCode: 500,
      body: JSON.stringify(e),
      headers: {
        'Access-Control-Allow-Origin': '*',
      },
    }
  }
}

handler: APIGatewayProxyHandler = async (event, context) => {
  if (!cachedServer) {
    const server = await bootstrapServer()
    cachedServer = server
    return proxy(server, event, context, 'PROMISE').promise
  } else {
    return proxy(cachedServer, event, context, 'PROMISE').promise
  }
}

handler: APIGatewayProxyHandler = async (event, context) => {
  if (!cachedServer) {
    const server = await bootstrapServer()
    cachedServer = server
    return proxy(server, event, context, 'PROMISE').promise
  } else {
    return proxy(cachedServer, event, context, 'PROMISE').promise
  }
}

handler: APIGatewayProxyHandler = async (
  event,
  context,
  callback,
) => {
  if (!cachedServer) {
    cachedServer = await bootstrapServer();
  }
  return cachedServer(event, context, callback);
}

handler: APIGatewayProxyHandler = async (event) => {
  const { id, limit, page } = event.queryStringParameters || {};
  const limitValue = Number(limit) || 1;
  const pageValue = Number(page) || 0;
  if (limitValue < 1) {
    return userError("Limit must be greater than 0", event);
  }
  if (pageValue < 0) {
    return userError("Page must be greater than or equal to 0", event);
  }
  if (!id) {
    return userError("Must include extension to look up versions", event);
  }
  return s3
    .listObjectsV2({ Bucket: "roamjs.com", Prefix: `${id}/`, Delimiter: "/" })
    .promise()
    .then((r) => {
      const allVersions = r.CommonPrefixes.map((c) => c.Prefix)
        .filter((s) => /\d\d\d\d-\d\d-\d\d-\d\d-\d\d/.test(s))
        .reverse();
      return {
        versions: allVersions
          .slice(pageValue, pageValue + limitValue)
          .map((s) => s.replace(id, "").replace(/\//g, "")),
        isEnd: pageValue + limitValue >= allVersions.length,
      };
    })
    .then((res) => ({
      statusCode: 200,
      body: JSON.stringify(res),
      headers: headers(event),
    }))
    .catch(emailCatch(`Failed to fetch versions for ${id}`, event));
}

handler: APIGatewayProxyHandler = (event) =>
  getClerkEmail(event).then((email) =>
    axios
      .post("https://api.convertkit.com/v3/forms/2239289/subscribe", {
        api_secret: ckApiSecret,
        email,
      })
      .then(() => bareSuccessResponse(event))
  )

handler: APIGatewayProxyHandler = (event) => {
  return getClerkEmail(event).then((email) =>
    axios
      .get(
        `https://api.convertkit.com/v3/subscribers?api_secret=${ckApiSecret}&email_address=${email}`
      )
      .then((ck) => ({
        statusCode: 200,
        body: JSON.stringify({ isSubscribed: ck.data.total_subscribers > 0 }),
        headers: headers(event),
      }))
  );
}

handler: APIGatewayProxyHandler = (event) =>
  getClerkEmail(event).then((email) =>
    axios
      .put("https://api.convertkit.com/v3/unsubscribe", {
        api_secret: ckApiSecret,
        email,
      })
      .then(() => emptyResponse(event))
  )

hello: APIGatewayProxyHandler = async (event, context) => {
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: "Go Serverless v2.0! Your function executed successfully!",
      context,
      event,
    }),
  };
}

handler: APIGatewayProxyHandler = async (event) => {
  const data = JSON.parse(event.body || "{}");
  const params = new URLSearchParams();
  Object.keys(data).forEach((k) => params.append(k, data[k]));

  return axios
    .post("https://api.dropboxapi.com/oauth2/token", params, {
      headers: {
        Authorization: `Basic ${Buffer.from(
          `${process.env.DROPBOX_CLIENT_ID}:${process.env.DROPBOX_CLIENT_SECRET}`
        ).toString("base64")}`,
        "Content-Type": "application/x-www-form-urlencoded",
      },
    })
    .then((r) => {
      if (data.grant_type === "refresh_token") {
        return {
          statusCode: 200,
          body: JSON.stringify(r.data),
          headers,
        };
      }
      return axios
        .post(
          "https://api.dropboxapi.com/2/users/get_account",
          { account_id: r.data.account_id },
          { headers: { Authorization: `Bearer ${r.data.access_token}` } }
        )
        .then((u) => ({
          statusCode: 200,
          body: JSON.stringify({ ...r.data, label: u.data.name.display_name }),
          headers,
        }));
    })
    .catch((e) => ({
      statusCode: 500,
      body: JSON.stringify(e.response?.data || { message: e.message }),
      headers,
    }));
}

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

    return response
}

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

    return response
}

handle: APIGatewayProxyHandler = async (event, _context) => {
  try {
    const result = await createController(event, documentClient);
    return httpResponse(result);
  } catch (error) {
    console.error(error);

    return httpResponse("Bad Request", 400);
  }
}

handle: APIGatewayProxyHandler = async (event, _context) => {
  try {
    const result = await deleteController(event, documentClient);
    return httpResponse(result);
  } catch (error) {
    console.error(error);

    return httpResponse("Bad Request", 400);
  }
}

handle: APIGatewayProxyHandler = async (event, _context) => {
  try {
    const result = await getController(event, documentClient);
    return httpResponse(result);
  } catch (error) {
    console.error(error);

    return httpResponse("Bad Request", 400);
  }
}

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
}

main: APIGatewayProxyHandler = async (event: APIGatewayProxyEvent) => {
    const { username } = event.pathParameters
    const { url } = JSON.parse(event.body)
    const photo = new Photo(username, url)
    await createPhoto(photo)
    const response = {
        statusCode: 200,
        body: JSON.stringify({
            photo
        })
    }

    return response
}

main: APIGatewayProxyHandler = async (event: APIGatewayProxyEvent) => {
    const { username, name } = JSON.parse(event.body)
    const user = new User(username, name)
    await createUser(user)
    const response = {
        statusCode: 200,
        body: JSON.stringify({
            user
        })
    }

    return response
}

main: APIGatewayProxyHandler = async (event: APIGatewayProxyEvent) => {
    const { username: followedUsername } = event.pathParameters
    const { followingUsername } = JSON.parse(event.body)
    const follow = await followUser(followedUsername, followingUsername)
    const response = {
        statusCode: 200,
        body: JSON.stringify({
            follow
        })
    }

    return response
}

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
}

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

    return response
}

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

    return response
}

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

    return response
}

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

    return response
}

handler: APIGatewayProxyHandler = authenticateDeveloper(
  (event) => {
    const userId = event.headers.Authorization;
    const { path } = JSON.parse(event.body || "{}");
    return dynamo
      .query({
        TableName,
        IndexName: "user-index",
        KeyConditionExpression: "#u = :u",
        ExpressionAttributeNames: { "#u": "user" },
        ExpressionAttributeValues: { ":u": { S: userId } },
      })
      .promise()
      .then((r) => r.Items.map((i) => i.id?.S))
      .then((paths) =>
        paths.includes(path.replace(/^([^/]+)\/(.*)$/, "$1"))
          ? sts
              .assumeRole({
                RoleArn: process.env.LAMBDA_ROLE,
                DurationSeconds: 900,
                RoleSessionName: `publish-${userId}`,
                Policy: JSON.stringify({
                  Version: "2012-10-17",
                  Statement: [
                    {
                      Sid: "PutPaths",
                      Effect: "Allow",
                      Action: "s3:PutObject",
                      Resource: [`arn:aws:s3:::roamjs.com/${path}/*`],
                    },
                    {
                      Sid: "InvalidateCache",
                      Effect: "Allow",
                      Action: [
                        "cloudfront:CreateInvalidation",
                        "cloudfront:GetInvalidation",
                      ],
                      Resource: process.env.CLOUDFRONT_ARN,
                    },
                  ],
                }),
              })
              .promise()
              .then((creds) => ({
                statusCode: 200,
                body: JSON.stringify({
                  credentials: creds.Credentials,
                  distributionId: /\/(.*)$/.exec(
                    process.env.CLOUDFRONT_ARN
                  )?.[1],
                }),
                headers: headers(event),
              }))
          : userError(`User not authorized to publish to path ${path}`, event)
      );
  }
)

authenticateDeveloper =
  (handler: APIGatewayProxyHandler): APIGatewayProxyHandler =>
  (event, ctx, callback) => {
    const Authorization =
      event.headers.Authorization || event.headers.authorization || "";
    const encryptionSecret = process.env.ENCRYPTION_SECRET;
    const [email, token] = Buffer.from(
      Authorization.replace(/^Bearer /, ""),
      "base64"
    )
      .toString()
      .split(":");

    return users
      .getUserList({ emailAddress: [email] })
      .then((us) =>
        us.find((u) => {
          const stored = AES.decrypt(
            u.privateMetadata.token as string,
            encryptionSecret
          ).toString(encutf8);
          return stored && stored === token;
        })
      )
      .catch(() => undefined)
      .then((user) => {
        if (!user) {
          return {
            statusCode: 401,
            body: "Invalid Developer token",
            headers: headers(event),
          };
        }
        if (!user.publicMetadata["developer"]) {
          return {
            statusCode: 403,
            body: "User has not signed up for the RoamJS Developer extension",
            headers: headers(event),
          };
        }
        event.headers.Authorization = user.id;
        const result = handler(event, ctx, callback);
        if (!result) {
          return emptyResponse(event);
        }
        return result;
      });
  }

getPDF: APIGatewayProxyHandler = async (event, _context) => {
  const response = await PDFGenerator.getPDF(event);
  return response;
}