@tryghost/errors 1.2.27 → 1.3.1

package/es/GhostError.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { v1 as uuidv1 } from "uuid";
+import { wrapStack } from "./wrap-stack";
+class GhostError extends Error {
+  constructor(options = {}) {
+    super();
+    __publicField(this, "statusCode");
+    __publicField(this, "errorType");
+    __publicField(this, "level");
+    __publicField(this, "id");
+    __publicField(this, "context");
+    __publicField(this, "help");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    __publicField(this, "errorDetails");
+    __publicField(this, "code");
+    __publicField(this, "property");
+    __publicField(this, "redirect");
+    __publicField(this, "hideStack");
+    this.statusCode = 500;
+    this.errorType = "InternalServerError";
+    this.level = "normal";
+    this.message = "The server has encountered an error.";
+    this.id = uuidv1();
+    this.id = options.id || this.id;
+    this.statusCode = options.statusCode || this.statusCode;
+    this.level = options.level || this.level;
+    this.context = options.context;
+    this.help = options.help;
+    this.errorType = this.name = options.errorType || this.errorType;
+    this.errorDetails = options.errorDetails;
+    this.code = options.code || null;
+    this.property = options.property || null;
+    this.redirect = options.redirect || null;
+    this.message = options.message || this.message;
+    this.hideStack = options.hideStack || false;
+    if (options.err) {
+      if (typeof options.err === "string") {
+        options.err = new Error(options.err);
+      }
+      Object.getOwnPropertyNames(options.err).forEach((property) => {
+        if (["errorType", "name", "statusCode", "message", "level"].indexOf(property) !== -1) {
+          return;
+        }
+        if (property === "code") {
+          this[property] = this[property] || options.err[property];
+          return;
+        }
+        if (property === "stack" && !this.hideStack) {
+          this[property] = wrapStack(this, options.err);
+          return;
+        }
+        this[property] = options.err[property] || this[property];
+      });
+    }
+  }
+}
+export {
+  GhostError
+};

package/es/errors.js

@@ -0,0 +1,310 @@
+import { GhostError } from "./GhostError";
+const mergeOptions = (options, defaults) => {
+  const result = { ...defaults };
+  Object.keys(options).forEach((key) => {
+    if (options[key] !== void 0) {
+      result[key] = options[key];
+    }
+  });
+  return result;
+};
+class InternalServerError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 500,
+      level: "critical",
+      errorType: "InternalServerError",
+      message: "The server has encountered an error."
+    }));
+  }
+}
+class IncorrectUsageError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 400,
+      level: "critical",
+      errorType: "IncorrectUsageError",
+      message: "We detected a misuse. Please read the stack trace."
+    }));
+  }
+}
+class NotFoundError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 404,
+      errorType: "NotFoundError",
+      message: "Resource could not be found.",
+      hideStack: true
+    }));
+  }
+}
+class BadRequestError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 400,
+      errorType: "BadRequestError",
+      message: "The request could not be understood."
+    }));
+  }
+}
+class UnauthorizedError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 401,
+      errorType: "UnauthorizedError",
+      message: "You are not authorised to make this request."
+    }));
+  }
+}
+class NoPermissionError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 403,
+      errorType: "NoPermissionError",
+      message: "You do not have permission to perform this request."
+    }));
+  }
+}
+class ValidationError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 422,
+      errorType: "ValidationError",
+      message: "The request failed validation."
+    }));
+  }
+}
+class UnsupportedMediaTypeError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 415,
+      errorType: "UnsupportedMediaTypeError",
+      message: "The media in the request is not supported by the server."
+    }));
+  }
+}
+class TooManyRequestsError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 429,
+      errorType: "TooManyRequestsError",
+      message: "Server has received too many similar requests in a short space of time."
+    }));
+  }
+}
+class MaintenanceError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 503,
+      errorType: "MaintenanceError",
+      message: "The server is temporarily down for maintenance."
+    }));
+  }
+}
+class MethodNotAllowedError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 405,
+      errorType: "MethodNotAllowedError",
+      message: "Method not allowed for resource."
+    }));
+  }
+}
+class RequestNotAcceptableError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 406,
+      errorType: "RequestNotAcceptableError",
+      message: "Request not acceptable for provided Accept-Version header.",
+      hideStack: true
+    }));
+  }
+}
+class RangeNotSatisfiableError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 416,
+      errorType: "RangeNotSatisfiableError",
+      message: "Range not satisfiable for provided Range header.",
+      hideStack: true
+    }));
+  }
+}
+class RequestEntityTooLargeError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 413,
+      errorType: "RequestEntityTooLargeError",
+      message: "Request was too big for the server to handle."
+    }));
+  }
+}
+class TokenRevocationError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 503,
+      errorType: "TokenRevocationError",
+      message: "Token is no longer available."
+    }));
+  }
+}
+class VersionMismatchError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 400,
+      errorType: "VersionMismatchError",
+      message: "Requested version does not match server version."
+    }));
+  }
+}
+class DataExportError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 500,
+      errorType: "DataExportError",
+      message: "The server encountered an error whilst exporting data."
+    }));
+  }
+}
+class DataImportError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 500,
+      errorType: "DataImportError",
+      message: "The server encountered an error whilst importing data."
+    }));
+  }
+}
+class EmailError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 500,
+      errorType: "EmailError",
+      message: "The server encountered an error whilst sending email."
+    }));
+  }
+}
+class ThemeValidationError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 422,
+      errorType: "ThemeValidationError",
+      message: "The theme has a validation error.",
+      errorDetails: {}
+    }));
+  }
+}
+class DisabledFeatureError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 409,
+      errorType: "DisabledFeatureError",
+      message: "Unable to complete the request, this feature is disabled."
+    }));
+  }
+}
+class UpdateCollisionError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      statusCode: 409,
+      errorType: "UpdateCollisionError",
+      message: "Unable to complete the request, there was a conflict."
+    }));
+  }
+}
+class HostLimitError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "HostLimitError",
+      hideStack: true,
+      statusCode: 403,
+      message: "Unable to complete the request, this resource is limited."
+    }));
+  }
+}
+class HelperWarning extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "HelperWarning",
+      hideStack: true,
+      statusCode: 400,
+      message: "A theme helper has done something unexpected."
+    }));
+  }
+}
+class PasswordResetRequiredError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "PasswordResetRequiredError",
+      statusCode: 401,
+      message: "For security, you need to create a new password. An email has been sent to you with instructions!"
+    }));
+  }
+}
+class UnhandledJobError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "UnhandledJobError",
+      message: "Processed job threw an unhandled error",
+      level: "critical"
+    }));
+  }
+}
+class NoContentError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "NoContentError",
+      statusCode: 204,
+      hideStack: true
+    }));
+  }
+}
+class ConflictError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "ConflictError",
+      statusCode: 409,
+      message: "The server has encountered an conflict."
+    }));
+  }
+}
+class MigrationError extends GhostError {
+  constructor(options = {}) {
+    super(mergeOptions(options, {
+      errorType: "MigrationError",
+      message: "An error has occurred applying a database migration.",
+      level: "critical"
+    }));
+  }
+}
+export {
+  BadRequestError,
+  ConflictError,
+  DataExportError,
+  DataImportError,
+  DisabledFeatureError,
+  EmailError,
+  HelperWarning,
+  HostLimitError,
+  IncorrectUsageError,
+  InternalServerError,
+  MaintenanceError,
+  MethodNotAllowedError,
+  MigrationError,
+  NoContentError,
+  NoPermissionError,
+  NotFoundError,
+  PasswordResetRequiredError,
+  RangeNotSatisfiableError,
+  RequestEntityTooLargeError,
+  RequestNotAcceptableError,
+  ThemeValidationError,
+  TokenRevocationError,
+  TooManyRequestsError,
+  UnauthorizedError,
+  UnhandledJobError,
+  UnsupportedMediaTypeError,
+  UpdateCollisionError,
+  ValidationError,
+  VersionMismatchError
+};

package/es/index.js

@@ -0,0 +1,14 @@
+import * as ghostErrors from "./errors";
+import { deserialize, isGhostError, prepareStackForUser, serialize } from "./utils";
+export * from "./errors";
+var src_default = ghostErrors;
+const utils = {
+  serialize,
+  deserialize,
+  isGhostError,
+  prepareStackForUser
+};
+export {
+  src_default as default,
+  utils
+};

package/es/utils.js

@@ -0,0 +1,174 @@
+import deepCopy from "@stdlib/utils-copy";
+import { GhostError } from "./GhostError";
+import * as errors from "./errors";
+const errorsWithBase = { ...errors, GhostError };
+const _private = {
+  serialize(err) {
+    try {
+      return {
+        id: err.id,
+        status: err.statusCode,
+        code: err.code || err.errorType,
+        title: err.name,
+        detail: err.message,
+        meta: {
+          context: err.context,
+          help: err.help,
+          errorDetails: err.errorDetails,
+          level: err.level,
+          errorType: err.errorType
+        }
+      };
+    } catch (error) {
+      return {
+        detail: "Something went wrong."
+      };
+    }
+  },
+  deserialize(obj) {
+    return {
+      id: obj.id,
+      message: obj.detail || obj.error_description || obj.message,
+      statusCode: obj.status,
+      code: obj.code || obj.error,
+      level: obj.meta && obj.meta.level,
+      help: obj.meta && obj.meta.help,
+      context: obj.meta && obj.meta.context
+    };
+  },
+  /**
+   * @description Serialize error instance into oauth format.
+   *
+   * @see https://tools.ietf.org/html/rfc6749#page-45
+   *
+   * To not loose any error data when sending errors between internal services, we use the suggested OAuth properties and add ours as well.
+   */
+  OAuthSerialize(err) {
+    const matchTable = {
+      [errors.NoPermissionError.name]: "access_denied",
+      [errors.MaintenanceError.name]: "temporarily_unavailable",
+      [errors.BadRequestError.name]: "invalid_request",
+      [errors.ValidationError.name]: "invalid_request",
+      default: "server_error"
+    };
+    const { detail, code, ...properties } = _private.serialize(err);
+    return {
+      error: err.code || matchTable[err.name] || "server_error",
+      error_description: err.message,
+      ...properties
+    };
+  },
+  /**
+   * @description Deserialize oauth error format into GhostError instance.
+   * @constructor
+   */
+  OAuthDeserialize(errorFormat) {
+    try {
+      return new errorsWithBase[errorFormat.title || errorFormat.name || errors.InternalServerError.name](_private.deserialize(errorFormat));
+    } catch (err) {
+      return new errors.InternalServerError({
+        errorType: errorFormat.title || errorFormat.name,
+        ..._private.deserialize(errorFormat)
+      });
+    }
+  },
+  /**
+   * @description Serialize GhostError instance into jsonapi.org format.
+   * @param err
+   * @return {Object}
+   */
+  JSONAPISerialize(err) {
+    const errorFormat = {
+      errors: [_private.serialize(err)]
+    };
+    errorFormat.errors[0].source = {};
+    if (err.property) {
+      errorFormat.errors[0].source.pointer = "/data/attributes/" + err.property;
+    }
+    return errorFormat;
+  },
+  /**
+   * @description Deserialize JSON api format into GhostError instance.
+   */
+  JSONAPIDeserialize(errorFormat) {
+    errorFormat = errorFormat.errors && errorFormat.errors[0] || {};
+    let internalError;
+    try {
+      internalError = new errorsWithBase[errorFormat.title || errorFormat.name || errors.InternalServerError.name](_private.deserialize(errorFormat));
+    } catch (err) {
+      internalError = new errors.InternalServerError({
+        errorType: errorFormat.title || errorFormat.name,
+        ..._private.deserialize(errorFormat)
+      });
+    }
+    if (errorFormat.source && errorFormat.source.pointer) {
+      internalError.property = errorFormat.source.pointer.split("/")[3];
+    }
+    return internalError;
+  }
+};
+function serialize(err, options) {
+  options = options || { format: "jsonapi" };
+  let errorFormat = {};
+  try {
+    if (options.format === "jsonapi") {
+      errorFormat = _private.JSONAPISerialize(err);
+    } else {
+      errorFormat = _private.OAuthSerialize(err);
+    }
+  } catch (error) {
+    errorFormat.message = "Something went wrong.";
+  }
+  return errorFormat;
+}
+;
+function deserialize(errorFormat) {
+  let internalError = {};
+  if (errorFormat.errors) {
+    internalError = _private.JSONAPIDeserialize(errorFormat);
+  } else {
+    internalError = _private.OAuthDeserialize(errorFormat);
+  }
+  return internalError;
+}
+;
+function prepareStackForUser(error) {
+  const stackbits = error.stack?.split(/\n/) || [];
+  const hideStack = "hideStack" in error && error.hideStack;
+  if (hideStack) {
+    stackbits.splice(1, stackbits.length - 1);
+  } else {
+    stackbits.splice(1, 0, `Stack Trace:`);
+  }
+  if ("help" in error && error.help) {
+    stackbits.splice(1, 0, `${error.help}`);
+  }
+  if ("context" in error && error.context) {
+    stackbits.splice(1, 0, `${error.context}`);
+  }
+  const errorClone = deepCopy(error);
+  errorClone.stack = stackbits.join("\n");
+  return errorClone;
+}
+;
+function isGhostError(err) {
+  const errorName = GhostError.name;
+  const legacyErrorName = "IgnitionError";
+  const recursiveIsGhostError = function recursiveIsGhostError2(obj) {
+    if (!obj || !obj.name) {
+      return false;
+    }
+    if (obj.name === errorName || obj.name === legacyErrorName) {
+      return true;
+    }
+    return recursiveIsGhostError2(Object.getPrototypeOf(obj));
+  };
+  return recursiveIsGhostError(err.constructor);
+}
+;
+export {
+  deserialize,
+  isGhostError,
+  prepareStackForUser,
+  serialize
+};

package/es/wrap-stack.js

@@ -0,0 +1,9 @@
+function wrapStack(err, internalErr) {
+  const extraLine = (err.stack?.split(/\n/g) || [])[1];
+  const [firstLine, ...rest] = internalErr.stack?.split(/\n/g) || [];
+  return [firstLine, extraLine, ...rest].join("\n");
+}
+;
+export {
+  wrapStack
+};

package/package.json

@@ -1,33 +1,50 @@
 {
   "name": "@tryghost/errors",
-  "version": "1.2.27",
+  "version": "1.3.1",
   "repository": "https://github.com/TryGhost/framework/tree/main/packages/errors",
   "author": "Ghost Foundation",
   "license": "MIT",
-  "main": "index.js",
+  "main": "cjs/index.js",
+  "module": "es/index.js",
+  "types": "types/index.d.ts",
+  "source": "src/index.ts",
+  "sideEffects": false,
   "scripts": {
     "dev": "echo \"Implement me!\"",
-    "test": "NODE_ENV=testing c8 --check-coverage --all --reporter text --reporter cobertura  mocha './test/**/*.test.js'",
+    "prepare": "NODE_ENV=production yarn build",
+    "pretest": "NODE_ENV=production yarn build",
+    "build": "yarn build:cjs && yarn build:es && yarn build:types",
+    "build:cjs": "esbuild src/*.ts --target=es2020 --outdir=cjs --format=cjs",
+    "build:es": "esbuild src/*.ts --target=es2020 --outdir=es --format=esm",
+    "build:types": "tsc --emitDeclarationOnly --declaration --declarationMap --outDir types",
+    "test": "TS_NODE_COMPILER_OPTIONS='{\"module\": \"commonjs\" }' NODE_ENV=testing c8 --check-coverage --all -n src --reporter text --reporter cobertura  mocha -r ts-node/register './test/**/*.test.ts'",
     "lint": "eslint . --ext .js --cache",
     "posttest": "yarn lint"
   },
   "files": [
-    "index.js",
-    "lib"
+    "cjs",
+    "es",
+    "types",
+    "src"
   ],
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "c8": "8.0.1",
-    "mocha": "10.2.0",
+    "@types/lodash": "^4.14.200",
+    "@types/mocha": "^10.0.3",
+    "@types/uuid": "^9.0.6",
+    "c8": "9.1.0",
+    "esbuild": "^0.19.5",
+    "lodash": "^4.17.21",
+    "mocha": "10.3.0",
     "should": "13.2.3",
-    "sinon": "17.0.1"
+    "ts-node": "^10.9.1",
+    "typescript": "5.2.2"
   },
   "dependencies": {
     "@stdlib/utils-copy": "^0.0.7",
-    "lodash": "^4.17.21",
     "uuid": "^9.0.0"
   },
-  "gitHead": "a655bcfba6531944b8fd997bf53ccefb9dcf1685"
+  "gitHead": "46cfa9c0bc277226048af7c1b98c797bccc05db5"
 }