@smooai/utils/dist/api/apiHandler.mjs

A collection of shared utilities and tools used across SmooAI projects. This package provides common functionality to standardize and simplify development across all SmooAI repositories.

import {
  errorHandler
} from "../chunk-J4AMGXE3.mjs";
import {
  ApiError
} from "../chunk-FLBIVOHD.mjs";
import {
  HumanReadableSchemaError
} from "../chunk-WKR62SAR.mjs";
import "../chunk-LZOMFHX3.mjs";

// src/api/apiHandler.ts
import ServerLogger from "@smooai/logger/AwsLambdaLogger";
import { getReasonPhrase, StatusCodes } from "http-status-codes";
import { ZodError } from "zod";
import { fromZodError } from "zod-validation-error";
var logger = new ServerLogger();
async function lambdaApiHandler(event, context, handler) {
  try {
    logger.addLambdaContext(event, context);
    return await errorHandler(
      async (event2, context2) => {
        const response = await handler(event2, context2);
        const awsLambdaResponse = {
          ...response,
          body: response.body ? typeof response.body === "string" ? response.body : JSON.stringify(response.body) : void 0
        };
        return awsLambdaResponse;
      },
      event,
      context
    );
  } catch (error) {
    if (error instanceof ApiError) {
      logger.error(error, `An API error occurred: Status: ${error.status} (${error.statusText}); Message: ${error.message}`);
      return {
        body: JSON.stringify({
          error: { message: error.message, statusText: error.statusText }
        }),
        statusCode: error.status,
        headers: { "Content-type": "application/json" }
      };
    } else if (error instanceof HumanReadableSchemaError) {
      logger.error(error, `A schema validation error occurred: ${error.message}`);
      return {
        body: JSON.stringify({
          error: {
            message: error.message,
            statusText: getReasonPhrase(StatusCodes.BAD_REQUEST)
          }
        }),
        statusCode: StatusCodes.BAD_REQUEST,
        headers: { "Content-type": "application/json" }
      };
    } else if (error instanceof ZodError) {
      const validationError = fromZodError(error);
      logger.error(error, `A validation error occurred: ${validationError}`);
      return {
        body: JSON.stringify({
          error: {
            message: error.message,
            statusText: getReasonPhrase(StatusCodes.BAD_REQUEST)
          }
        }),
        statusCode: StatusCodes.BAD_REQUEST,
        headers: { "Content-type": "application/json" }
      };
    } else if (error instanceof Error) {
      logger.error(error, `An unexpected error occurred: ${error.message}`);
      return {
        body: JSON.stringify({
          error: {
            message: error.message,
            statusText: getReasonPhrase(StatusCodes.INTERNAL_SERVER_ERROR)
          }
        }),
        statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
        headers: { "Content-type": "application/json" }
      };
    } else {
      logger.error(error, `An unexpected error occurred: ${error}`);
      return {
        body: JSON.stringify({
          error: {
            message: "An unexpected error occurred.",
            statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
            statusText: getReasonPhrase(StatusCodes.INTERNAL_SERVER_ERROR),
            headers: { "Content-type": "application/json" }
          }
        })
      };
    }
  }
}
async function eventBridgeHandler(event, context, handler) {
  try {
    logger.addLambdaContext(void 0, context);
    return await errorHandler(
      async (event2, context2) => {
        await handler(event2, context2);
      },
      event,
      context
    );
  } catch (error) {
    if (error instanceof ApiError) {
      logger.error(error, `An API error occurred: Status: ${error.status} (${error.statusText}); Message: ${error.message}`);
    } else if (error instanceof HumanReadableSchemaError) {
      logger.error(error, `A schema validation error occurred: ${error.message}`);
    } else if (error instanceof ZodError) {
      const validationError = fromZodError(error);
      logger.error(error, `A validation error occurred: ${validationError}`);
    } else if (error instanceof Error) {
      logger.error(error, `An unexpected error occurred: ${error.message}`);
    } else {
      logger.error(error, `An unexpected error occurred: ${error}`);
    }
  }
}
async function sqsHandler(event, context, handler) {
  try {
    logger.addLambdaContext(void 0, context);
    return await errorHandler(
      async (event2, context2) => {
        return await handler(event2, context2);
      },
      event,
      context
    );
  } catch (error) {
    if (error instanceof ApiError) {
      logger.error(error, `An API error occurred: Status: ${error.status} (${error.statusText}); Message: ${error.message}`);
    } else if (error instanceof HumanReadableSchemaError) {
      logger.error(error, `A schema validation error occurred: ${error.message}`);
    } else if (error instanceof ZodError) {
      const validationError = fromZodError(error);
      logger.error(error, `A validation error occurred: ${validationError}`);
    } else if (error instanceof Error) {
      logger.error(error, `An unexpected error occurred: ${error.message}`);
    } else {
      logger.error(error, `An unexpected error occurred: ${error}`);
    }
    if (event.Records?.length) {
      return Promise.allSettled(event.Records.map((_record) => Promise.reject(error)));
    } else {
      return Promise.reject(error);
    }
  }
}
export {
  eventBridgeHandler,
  lambdaApiHandler,
  sqsHandler
};
//# sourceMappingURL=apiHandler.mjs.map