edgespec/dist/middleware/index.cjs

Write Winter-CG compatible routes with filesystem routing and tons of features

'use strict';

var kleur = require('kleur');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var kleur__default = /*#__PURE__*/_interopDefault(kleur);

// src/lib/format-zod-error.ts
var zodIssueToString = (issue) => {
  if (issue.path.join(".") === "") {
    return issue.message;
  }
  if (issue.message === "Required") {
    return `\`${issue.path.join(".")}\` is required`;
  }
  return `${issue.message} for "${issue.path.join(".")}"`;
};
var formatZodError = (error) => {
  let message;
  if (error.issues.length === 1) {
    const issue = error.issues[0];
    message = zodIssueToString(issue);
  } else {
    const message_components = [];
    for (const issue of error.issues) {
      message_components.push(zodIssueToString(issue));
    }
    message = `${error.issues.length} Zod validation issues: ` + message_components.join(", ");
  }
  message += `. Full Zod error: ${JSON.stringify(error.issues, null, 2)}`;
  return message;
};

// src/middleware/http-exceptions.ts
var EdgeSpecMiddlewareError = class extends Error {
  constructor(message, status = 500) {
    super(message);
    this.message = message;
    this.status = status;
    this._isHttpException = true;
    this.name = this.constructor.name;
  }
};
var MethodNotAllowedError = class extends EdgeSpecMiddlewareError {
  constructor(allowedMethods) {
    super(`only ${allowedMethods.join(",")} accepted`, 405);
  }
};
var NotFoundError = class extends EdgeSpecMiddlewareError {
  constructor(message) {
    super(message, 404);
  }
};
var BadRequestError = class extends EdgeSpecMiddlewareError {
  constructor(message) {
    super(message, 400);
  }
};
var InvalidQueryParamsError = class extends BadRequestError {
  constructor(message) {
    super(message);
  }
};
var InvalidContentTypeError = class extends BadRequestError {
  constructor(message) {
    super(message);
  }
};
var InputParsingError = class extends BadRequestError {
  constructor(message) {
    super(message);
  }
};
var InputValidationError = class extends BadRequestError {
  constructor(error) {
    super(formatZodError(error));
  }
};
var ResponseValidationError = class extends EdgeSpecMiddlewareError {
  constructor(error) {
    super(formatZodError(error), 500);
  }
};
var createWithDefaultExceptionHandling = ({
  coloredLogs = true,
  logWhen = (status) => status >= 500,
  includeStackTraceInResponse = true
} = {}) => async (req, ctx, next) => {
  try {
    return await next(req, ctx);
  } catch (e) {
    let response;
    if ("_isHttpException" in e) {
      response = Response.json(
        {
          message: e.message,
          stack: includeStackTraceInResponse ? e.stack : void 0
        },
        {
          status: e.status
        }
      );
    } else {
      response = Response.json(
        {
          message: "Internal server error",
          stack: includeStackTraceInResponse ? e.stack : void 0
        },
        {
          status: 500
        }
      );
    }
    if (logWhen(response.status, e)) {
      const logger = ctx.logger ?? console;
      kleur__default.default.enabled = coloredLogs;
      const { pathname } = new URL(req.url);
      const routeLog = response.status >= 500 ? kleur__default.default.bgRed(`${pathname} threw an error`) : kleur__default.default.bgYellow(`${pathname} threw an error`);
      logger.error(
        `${routeLog}: ${e instanceof Error ? e.stack : e.toString()}`
      );
    }
    return response;
  }
};

// src/middleware/with-logger.ts
var createWithLogger = (logger) => (req, ctx, next) => {
  ctx.logger = logger;
  return next(req, ctx);
};

exports.BadRequestError = BadRequestError;
exports.EdgeSpecMiddlewareError = EdgeSpecMiddlewareError;
exports.InputParsingError = InputParsingError;
exports.InputValidationError = InputValidationError;
exports.InvalidContentTypeError = InvalidContentTypeError;
exports.InvalidQueryParamsError = InvalidQueryParamsError;
exports.MethodNotAllowedError = MethodNotAllowedError;
exports.NotFoundError = NotFoundError;
exports.ResponseValidationError = ResponseValidationError;
exports.createWithDefaultExceptionHandling = createWithDefaultExceptionHandling;
exports.createWithLogger = createWithLogger;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map