@lucidcms/core/dist/chunk-7SRFYA4B.js

The core of the Lucid CMS. It's responsible for spinning up the API and serving the CMS.

import {
  constants_default,
  translations_default
} from "./chunk-7XW7FQ7W.js";

// src/utils/errors/error-type-defaults.ts
var errorTypeDefaults = (error) => {
  switch (error.type) {
    case "validation": {
      return {
        status: 400,
        name: error.name ?? translations_default("validation_error"),
        message: error.message ?? translations_default("validation_error_message")
      };
    }
    case "authorisation": {
      return {
        status: 401,
        name: error.name ?? translations_default("authorisation_error"),
        message: error.message ?? translations_default("authorisation_error_message")
      };
    }
    case "forbidden": {
      return {
        status: 403,
        name: error.name ?? translations_default("forbidden_error"),
        message: error.message ?? translations_default("forbidden_error_message")
      };
    }
    default: {
      return {
        status: error.status,
        name: error.name,
        message: error.message
      };
    }
  }
};
var error_type_defaults_default = errorTypeDefaults;

// src/utils/errors/lucid-api-error.ts
var LucidAPIError = class _LucidAPIError extends Error {
  error;
  constructor(error) {
    super(error.message);
    this.error = error;
    if (error.zod !== void 0) {
      this.error.errorResponse = _LucidAPIError.formatZodErrors(
        error.zod?.issues || []
      );
    }
    const errorTypeRes = error_type_defaults_default(error);
    this.error.status = errorTypeRes.status;
    this.name = errorTypeRes.name ?? constants_default.errors.name;
    this.message = errorTypeRes.message ?? constants_default.errors.message;
  }
  // static
  static formatZodErrors(error) {
    const result = {};
    for (const item of error) {
      let current = result;
      for (const key of item.path) {
        if (typeof key === "number") {
          current = current.children || (current.children = []);
          current = current[key] || (current[key] = {});
        } else {
          current = current[key] || (current[key] = {});
        }
      }
      current.code = item.code;
      current.message = item.message;
    }
    return result ?? void 0;
  }
};
var lucid_api_error_default = LucidAPIError;

// src/utils/logging/logger.ts
import { format, createLogger } from "winston";
import transports from "winston/lib/winston/transports/index.js";
var winstonLogger = createLogger({
  level: "info",
  format: format.json()
});
if (process.env.NODE_ENV !== "production") {
  winstonLogger.add(
    new transports.Console({
      format: format.combine(format.colorize(), format.simple())
    })
  );
}
var logger_default = winstonLogger;

// src/utils/logging/index.ts
var logger = (level, data) => {
  let logFn = logger_default.error;
  switch (level) {
    case "error":
      logFn = logger_default.error;
      break;
    case "warn":
      logFn = logger_default.warn;
      break;
    case "info":
      logFn = logger_default.info;
      break;
    case "debug":
      logFn = logger_default.debug;
      break;
    default:
      logFn = logger_default.error;
      break;
  }
  logFn(messageFormat(level, data), data.data);
};
var messageFormat = (level, data) => {
  const msgParts = [data.message];
  if (data.scope) {
    msgParts.unshift(`[${data.scope}]`);
  }
  return msgParts.join(" ");
};
var logging_default = logger;

// src/utils/errors/lucid-error.ts
var LucidError = class extends Error {
  scope;
  kill;
  constructor(data) {
    super(data.message);
    this.scope = data.scope;
    this.kill = data.kill;
    logging_default("error", {
      message: this.message,
      scope: this.scope,
      data: data.data ?? void 0
    });
    if (this.kill) process.exit(1);
  }
};
var lucid_error_default = LucidError;

// src/utils/errors/decode-error.ts
var decodeError = (error) => {
  if (error instanceof lucid_api_error_default) {
    return {
      name: error.error.name,
      message: error.error.message,
      status: error.error.status,
      errorResponse: error.error.errorResponse,
      code: error.error.code
    };
  }
  if (error?.statusCode === 429) {
    return {
      code: "rate_limit",
      name: translations_default("rate_limit_error_name"),
      message: error.message || constants_default.errors.message,
      status: 429
    };
  }
  return {
    name: constants_default.errors.name,
    message: error.message || constants_default.errors.message,
    status: constants_default.errors.status,
    errorResponse: constants_default.errors.errorResponse,
    code: constants_default.errors.code
  };
};
var decode_error_default = decodeError;

// src/utils/errors/tidy-zod-errors.ts
import z from "zod";
var tidyZodError = (error) => {
  return z.prettifyError(error).replace(/✖/g, "");
};
var tidy_zod_errors_default = tidyZodError;

export {
  decode_error_default,
  error_type_defaults_default,
  lucid_api_error_default,
  logger_default,
  logging_default,
  lucid_error_default,
  tidy_zod_errors_default
};
//# sourceMappingURL=chunk-7SRFYA4B.js.map