@tryghost/errors 1.2.26 → 1.3.0

package/types/errors.d.ts

@@ -0,0 +1,86 @@
+import { GhostError, GhostErrorOptions } from './GhostError';
+export declare class InternalServerError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class IncorrectUsageError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class NotFoundError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class BadRequestError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class UnauthorizedError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class NoPermissionError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class ValidationError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class UnsupportedMediaTypeError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class TooManyRequestsError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class MaintenanceError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class MethodNotAllowedError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class RequestNotAcceptableError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class RequestEntityTooLargeError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class TokenRevocationError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class VersionMismatchError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class DataExportError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class DataImportError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class EmailError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class ThemeValidationError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class DisabledFeatureError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class UpdateCollisionError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class HostLimitError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class HelperWarning extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class PasswordResetRequiredError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class UnhandledJobError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class NoContentError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class ConflictError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+export declare class MigrationError extends GhostError {
+    constructor(options?: GhostErrorOptions);
+}
+//# sourceMappingURL=errors.d.ts.map

package/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,iBAAiB,EAAC,MAAM,cAAc,CAAC;AAe3D,qBAAa,mBAAoB,SAAQ,UAAU;gBACnC,OAAO,GAAE,iBAAsB;CAQ9C;AAED,qBAAa,mBAAoB,SAAQ,UAAU;gBACnC,OAAO,GAAE,iBAAsB;CAQ9C;AAED,qBAAa,aAAc,SAAQ,UAAU;gBAC7B,OAAO,GAAE,iBAAsB;CAQ9C;AAED,qBAAa,eAAgB,SAAQ,UAAU;gBAC/B,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,iBAAkB,SAAQ,UAAU;gBACjC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,iBAAkB,SAAQ,UAAU;gBACjC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,eAAgB,SAAQ,UAAU;gBAC/B,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,yBAA0B,SAAQ,UAAU;gBACzC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,oBAAqB,SAAQ,UAAU;gBACpC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,gBAAiB,SAAQ,UAAU;gBAChC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,qBAAsB,SAAQ,UAAU;gBACrC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,yBAA0B,SAAQ,UAAU;gBACzC,OAAO,GAAE,iBAAsB;CAQ9C;AAED,qBAAa,0BAA2B,SAAQ,UAAU;gBAC1C,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,oBAAqB,SAAQ,UAAU;gBACpC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,oBAAqB,SAAQ,UAAU;gBACpC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,eAAgB,SAAQ,UAAU;gBAC/B,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,eAAgB,SAAQ,UAAU;gBAC/B,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,UAAW,SAAQ,UAAU;gBAC1B,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,oBAAqB,SAAQ,UAAU;gBACpC,OAAO,GAAE,iBAAsB;CAQ9C;AAED,qBAAa,oBAAqB,SAAQ,UAAU;gBACpC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,oBAAqB,SAAQ,UAAU;gBACpC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,cAAe,SAAQ,UAAU;gBAC9B,OAAO,GAAE,iBAAsB;CAQ9C;AAED,qBAAa,aAAc,SAAQ,UAAU;gBAC7B,OAAO,GAAE,iBAAsB;CAQ9C;AAED,qBAAa,0BAA2B,SAAQ,UAAU;gBAC1C,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,iBAAkB,SAAQ,UAAU;gBACjC,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,cAAe,SAAQ,UAAU;gBAC9B,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,aAAc,SAAQ,UAAU;gBAC7B,OAAO,GAAE,iBAAsB;CAO9C;AAED,qBAAa,cAAe,SAAQ,UAAU;gBAC9B,OAAO,GAAE,iBAAsB;CAO9C"}

package/types/index.d.ts

@@ -0,0 +1,13 @@
+import { GhostError } from './GhostError';
+import * as ghostErrors from './errors';
+import { deserialize, isGhostError, prepareStackForUser, serialize } from './utils';
+export * from './errors';
+export type { GhostError };
+export default ghostErrors;
+export declare const utils: {
+    serialize: typeof serialize;
+    deserialize: typeof deserialize;
+    isGhostError: typeof isGhostError;
+    prepareStackForUser: typeof prepareStackForUser;
+};
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,WAAW,MAAM,UAAU,CAAC;AACxC,OAAO,EAAC,WAAW,EAAE,YAAY,EAAE,mBAAmB,EAAE,SAAS,EAAC,MAAM,SAAS,CAAC;AAElF,cAAc,UAAU,CAAC;AACzB,YAAY,EAAC,UAAU,EAAC,CAAC;AACzB,eAAe,WAAW,CAAC;AAE3B,eAAO,MAAM,KAAK;;;;;CAKjB,CAAC"}

package/types/utils.d.ts

@@ -0,0 +1,33 @@
+import { GhostError } from './GhostError';
+type AnyObject = Record<string, any>;
+/**
+ * @description Serialize GhostError instance to error JSON format
+ *
+ * jsonapi.org error format:
+ *
+ *  source: {
+ *      parameter: URL query parameter (no support yet)
+ *      pointer: HTTP body attribute
+ *  }
+ *
+ * @see http://jsonapi.org/format/#errors
+ */
+export declare function serialize(err: GhostError, options?: {
+    format: 'jsonapi' | 'oauth';
+}): AnyObject;
+/**
+ * @description Deserialize from error JSON format to GhostError instance
+ */
+export declare function deserialize(errorFormat: AnyObject): AnyObject;
+/**
+ * @description Replace the stack with a user-facing one
+ * @returns Clone of the original error with a user-facing stack
+ */
+export declare function prepareStackForUser(error: GhostError): GhostError;
+export declare function prepareStackForUser(error: Error): Error;
+/**
+ * @description Check whether an error instance is a GhostError.
+ */
+export declare function isGhostError(err: Error): boolean;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAIxC,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AA+HpC;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE;IAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAA;CAAC,aAiBjF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,SAAS,GAAG,SAAS,CAU7D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAAA;AAClE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAA;AAiCxD;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,KAAK,WAkBtC"}

package/types/wrap-stack.d.ts

@@ -0,0 +1,2 @@
+export declare function wrapStack(err: Error, internalErr: Error): string;
+//# sourceMappingURL=wrap-stack.d.ts.map

package/types/wrap-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-stack.d.ts","sourceRoot":"","sources":["../src/wrap-stack.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,UAIvD"}

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./lib/errors');

package/lib/errors.js

@@ -1,340 +0,0 @@
-const uuid = require('uuid');
-const merge = require('lodash/merge');
-const isString = require('lodash/isString');
-const utils = require('./utils');
-
-class GhostError extends Error {
-    constructor(options = {}) {
-        super();
-
-        /**
-         * defaults
-         */
-        this.statusCode = 500;
-        this.errorType = 'InternalServerError';
-        this.level = 'normal';
-        this.message = 'The server has encountered an error.';
-        this.id = uuid.v1();
-
-        /**
-         * custom overrides
-         */
-        this.id = options.id || this.id;
-        this.statusCode = options.statusCode || this.statusCode;
-        this.level = options.level || this.level;
-        this.context = options.context || this.context;
-        this.help = options.help || this.help;
-        this.errorType = this.name = options.errorType || this.errorType;
-        this.errorDetails = options.errorDetails;
-        // @ts-ignore
-        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;
-
-        // NOTE: Error to inherit from, override!
-        //       Nested objects are getting copied over in one piece (can be changed, but not needed right now)
-        if (options.err) {
-            // CASE: Support err as string (it happens that third party libs return a string instead of an error instance)
-            if (isString(options.err)) {
-                /* eslint-disable no-restricted-syntax */
-                options.err = new Error(options.err);
-                /* eslint-enable no-restricted-syntax */
-            }
-
-            Object.getOwnPropertyNames(options.err).forEach((property) => {
-                if (['errorType', 'name', 'statusCode', 'message', 'level'].indexOf(property) !== -1) {
-                    return;
-                }
-
-                // CASE: `code` should put options as priority over err
-                if (property === 'code') {
-                    // @ts-ignore
-                    this[property] = this[property] || options.err[property];
-                    return;
-                }
-
-                if (property === 'stack' && !this.hideStack) {
-                    this[property] = utils.wrapStack(this, options.err);
-                    return;
-                }
-
-                this[property] = options.err[property] || this[property];
-            });
-        }
-    }
-}
-
-const ghostErrors = {
-    InternalServerError: class InternalServerError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 500,
-                level: 'critical',
-                errorType: 'InternalServerError',
-                message: 'The server has encountered an error.'
-            }, options));
-        }
-    },
-    IncorrectUsageError: class IncorrectUsageError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 400,
-                level: 'critical',
-                errorType: 'IncorrectUsageError',
-                message: 'We detected a misuse. Please read the stack trace.'
-            }, options));
-        }
-    },
-    NotFoundError: class NotFoundError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 404,
-                errorType: 'NotFoundError',
-                message: 'Resource could not be found.',
-                hideStack: true
-            }, options));
-        }
-    },
-    BadRequestError: class BadRequestError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 400,
-                errorType: 'BadRequestError',
-                message: 'The request could not be understood.'
-            }, options));
-        }
-    },
-    UnauthorizedError: class UnauthorizedError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 401,
-                errorType: 'UnauthorizedError',
-                message: 'You are not authorised to make this request.'
-            }, options));
-        }
-    },
-    NoPermissionError: class NoPermissionError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 403,
-                errorType: 'NoPermissionError',
-                message: 'You do not have permission to perform this request.'
-            }, options));
-        }
-    },
-    ValidationError: class ValidationError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 422,
-                errorType: 'ValidationError',
-                message: 'The request failed validation.'
-            }, options));
-        }
-    },
-    UnsupportedMediaTypeError: class UnsupportedMediaTypeError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 415,
-                errorType: 'UnsupportedMediaTypeError',
-                message: 'The media in the request is not supported by the server.'
-            }, options));
-        }
-    },
-    TooManyRequestsError: class TooManyRequestsError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 429,
-                errorType: 'TooManyRequestsError',
-                message: 'Server has received too many similar requests in a short space of time.'
-            }, options));
-        }
-    },
-    MaintenanceError: class MaintenanceError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 503,
-                errorType: 'MaintenanceError',
-                message: 'The server is temporarily down for maintenance.'
-            }, options));
-        }
-    },
-    MethodNotAllowedError: class MethodNotAllowedError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 405,
-                errorType: 'MethodNotAllowedError',
-                message: 'Method not allowed for resource.'
-            }, options));
-        }
-    },
-    RequestNotAcceptableError: class RequestNotAcceptableError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 406,
-                errorType: 'RequestNotAcceptableError',
-                message: 'Request not acceptable for provided Accept-Version header.',
-                hideStack: true
-            }, options));
-        }
-    },
-    RequestEntityTooLargeError: class RequestEntityTooLargeError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 413,
-                errorType: 'RequestEntityTooLargeError',
-                message: 'Request was too big for the server to handle.'
-            }, options));
-        }
-    },
-    TokenRevocationError: class TokenRevocationError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 503,
-                errorType: 'TokenRevocationError',
-                message: 'Token is no longer available.'
-            }, options));
-        }
-    },
-    VersionMismatchError: class VersionMismatchError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 400,
-                errorType: 'VersionMismatchError',
-                message: 'Requested version does not match server version.'
-            }, options));
-        }
-    },
-    DataExportError: class DataExportError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 500,
-                errorType: 'DataExportError',
-                message: 'The server encountered an error whilst exporting data.'
-            }, options));
-        }
-    },
-    DataImportError: class DataImportError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 500,
-                errorType: 'DataImportError',
-                message: 'The server encountered an error whilst importing data.'
-            }, options));
-        }
-    },
-    EmailError: class EmailError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 500,
-                errorType: 'EmailError',
-                message: 'The server encountered an error whilst sending email.'
-            }, options));
-        }
-    },
-    ThemeValidationError: class ThemeValidationError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 422,
-                errorType: 'ThemeValidationError',
-                message: 'The theme has a validation error.',
-                errorDetails: {}
-            }, options));
-        }
-    },
-    DisabledFeatureError: class DisabledFeatureError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 409,
-                errorType: 'DisabledFeatureError',
-                message: 'Unable to complete the request, this feature is disabled.'
-            }, options));
-        }
-    },
-    UpdateCollisionError: class UpdateCollisionError extends GhostError {
-        constructor(options) {
-            super(merge({
-                statusCode: 409,
-                errorType: 'UpdateCollisionError',
-                message: 'Unable to complete the request, there was a conflict.'
-            }, options));
-        }
-    },
-    HostLimitError: class HostLimitError extends GhostError {
-        constructor(options) {
-            super(merge({
-                errorType: 'HostLimitError',
-                hideStack: true,
-                statusCode: 403,
-                message: 'Unable to complete the request, this resource is limited.'
-            }, options));
-        }
-    },
-    HelperWarning: class HelperWarning extends GhostError {
-        constructor(options) {
-            super(merge({
-                errorType: 'HelperWarning',
-                hideStack: true,
-                statusCode: 400,
-                message: 'A theme helper has done something unexpected.'
-            }, options));
-        }
-    },
-    PasswordResetRequiredError: class PasswordResetRequiredError extends GhostError {
-        constructor(options) {
-            super(merge({
-                errorType: 'PasswordResetRequiredError',
-                statusCode: 401,
-                message: 'For security, you need to create a new password. An email has been sent to you with instructions!'
-            }, options));
-        }
-    },
-    UnhandledJobError: class UnhandledJobError extends GhostError {
-        constructor(options) {
-            super(merge({
-                errorType: 'UnhandledJobError',
-                message: 'Processed job threw an unhandled error',
-                level: 'critical'
-            }, options));
-        }
-    },
-    NoContentError: class NoContentError extends GhostError {
-        constructor(options) {
-            super(merge({
-                errorType: 'NoContentError',
-                statusCode: 204,
-                hideStack: true
-            }, options));
-        }
-    },
-    ConflictError: class ConflictError extends GhostError {
-        constructor(options) {
-            super(merge({
-                errorType: 'ConflictError',
-                statusCode: 409,
-                message: 'The server has encountered an conflict.'
-            }, options));
-        }
-    },
-    MigrationError: class MigrationError extends GhostError {
-        constructor(options) {
-            super(merge({
-                errorType: 'MigrationError',
-                message: 'An error has occurred applying a database migration.',
-                level: 'critical'
-            }, options));
-        }
-    }
-};
-
-module.exports = ghostErrors;
-
-const ghostErrorsWithBase = Object.assign({}, ghostErrors, {GhostError});
-module.exports.utils = {
-    serialize: utils.serialize.bind(ghostErrorsWithBase),
-    deserialize: utils.deserialize.bind(ghostErrorsWithBase),
-    isGhostError: utils.isGhostError.bind(ghostErrorsWithBase),
-    prepareStackForUser: utils.prepareStackForUser
-};