@jakubmazanec/error 1.0.1-next.c5848fd → 2.0.0-9cfd7b2

package/src/createCustomErrorWithData.ts

@@ -0,0 +1,79 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */
+import {type z, type AnyZodObject} from 'zod';
+
+import {INTERNAL_ERROR_MESSAGES, UNKNOWN_ERROR} from './constants.js';
+import {createErrorMessage} from './internals.js';
+import {
+  type CustomErrorWithData,
+  type CustomErrorWithDataOptions,
+  type ErrorMessages,
+} from './types.js';
+
+/**
+ * Function for creating custom error classes. Such custom error class properly subclasses built-in `Error`, simplifies
+ * generating error messages via predefined error codes and allows attaching custom data to the error instance.
+ *
+ * @param errorName Error name.
+ * @param errorMessages Object containing all possible error messages.
+ * @param errorData Runtime representation of the `ErrorData` type parameter; can be either a class expression, or a Zod schema.
+ * @return Class that implements {@linkcode CustomErrorWithData}.
+ */
+export function createCustomErrorWithData<ErrorCode extends string, ErrorData extends AnyZodObject>(
+  errorName: string,
+  errorMessages: ErrorMessages<ErrorCode>,
+  errorData: ErrorData,
+): new (
+  code: ErrorCode,
+  options?: CustomErrorWithDataOptions<z.infer<ErrorData>>,
+) => CustomErrorWithData<ErrorCode | typeof UNKNOWN_ERROR, z.infer<ErrorData>>;
+export function createCustomErrorWithData<
+  ErrorCode extends string,
+  ErrorData extends abstract new (...args: any) => any,
+>(
+  errorName: string,
+  errorMessages: ErrorMessages<ErrorCode>,
+  errorData: ErrorData,
+): new (
+  code: ErrorCode,
+  options?: CustomErrorWithDataOptions<InstanceType<ErrorData>>,
+) => CustomErrorWithData<ErrorCode | typeof UNKNOWN_ERROR, InstanceType<ErrorData>>;
+export function createCustomErrorWithData<ErrorCode extends string, ErrorData>(
+  errorName: string,
+  errorMessages: ErrorMessages<ErrorCode>,
+  errorData: ErrorData,
+): new (code: ErrorCode, options?: CustomErrorWithDataOptions<ErrorData>) => CustomErrorWithData<
+  ErrorCode | typeof UNKNOWN_ERROR,
+  ErrorData
+> {
+  return class InternalCustomError
+    extends Error
+    implements CustomErrorWithData<ErrorCode, ErrorData>
+  {
+    code: ErrorCode | typeof UNKNOWN_ERROR;
+    data?: ErrorData;
+
+    constructor(errorCode: ErrorCode, options?: CustomErrorWithDataOptions<ErrorData>) {
+      let errorMessage = createErrorMessage(errorCode, errorMessages, options?.messageParameters);
+      let errorOptions: ErrorOptions = {};
+
+      if (typeof options?.cause !== 'undefined') {
+        errorOptions.cause = options.cause;
+      }
+
+      super(errorMessage, errorOptions);
+
+      this.code = errorCode;
+      this.name = errorName;
+
+      if (typeof options?.data !== 'undefined') {
+        this.data = options.data;
+      }
+
+      // if the message is empty, we are making this an unknown error
+      if (!this.message) {
+        this.code = UNKNOWN_ERROR;
+        this.message = createErrorMessage(UNKNOWN_ERROR, INTERNAL_ERROR_MESSAGES);
+      }
+    }
+  };
+}

package/src/internals/createErrorMessage.ts

@@ -0,0 +1,27 @@
+import {ERROR_MESSAGE_TOKEN_PATTERN} from '../constants.js';
+import {type ErrorMessages} from '../types.js';
+
+/**
+ * A function that generates an error message based on provided error code and message parameters. It is used only internally.
+ *
+ * @param errorCode Error code.
+ * @param errorMessages Object containing all possible error messages.
+ * @param messageParameters Array of values that are used as message parameters.
+ * @return Error message.
+ */
+export function createErrorMessage<T extends string>(
+  errorCode: T,
+  errorMessages: ErrorMessages<T>,
+  messageParameters: unknown[] = [],
+): string {
+  let errorMessage = errorMessages[errorCode];
+
+  if (!errorMessage) {
+    return '';
+  }
+
+  return `${errorCode}: ${errorMessage.replace(
+    ERROR_MESSAGE_TOKEN_PATTERN,
+    (match: string, index: number) => String(messageParameters[index]),
+  )}`;
+}

package/src/internals.ts

@@ -0,0 +1 @@
+export * from './internals/createErrorMessage.js';

package/src/main.ts

@@ -1,2 +1,4 @@
 export * from './createCustomError.js';
+export * from './createCustomErrorWithData.js';
 export * from './types.js';
+export {UNKNOWN_ERROR} from './constants.js';

package/src/types/CustomError.ts

@@ -1,12 +1,9 @@
-import type {UNKNOWN_ERROR} from '../constants.js';
+import {type UNKNOWN_ERROR} from '../constants.js';
 
 /**
  * Type representing custom error.
  */
-export type CustomError<ErrorCode extends string, ErrorData> = Error & {
+export type CustomError<ErrorCode extends string> = Error & {
   /** String that is used to quickly determine the nature of the error and why it could have occurred. */
   code: ErrorCode | typeof UNKNOWN_ERROR;
-
-  /** Data related to the error that can be used during the error handling process to gain more information or take an action. */
-  data?: ErrorData;
 };

package/src/types/CustomErrorOptions.ts

@@ -0,0 +1,10 @@
+/**
+ * Type representing options object used when instantianting class returned from {@linkcode createCustomError}.
+ */
+export type CustomErrorOptions = {
+  /** Array of values that are used as parameters to generate the error message. */
+  messageParameters?: unknown[];
+
+  /** Used for setting `cause` property of an error instance that indicates the specific original cause of the error. */
+  cause?: unknown;
+};

package/src/types/CustomErrorWithData.ts

@@ -0,0 +1,12 @@
+import type {UNKNOWN_ERROR} from '../constants.js';
+
+/**
+ * Type representing custom error that can have an arbitrary data attached.
+ */
+export type CustomErrorWithData<ErrorCode extends string, ErrorData> = Error & {
+  /** String that is used to quickly determine the nature of the error and why it could have occurred. */
+  code: ErrorCode | typeof UNKNOWN_ERROR;
+
+  /** Data related to the error that can be used during the error handling process to gain more information or take an action. */
+  data?: ErrorData;
+};

package/src/types/CustomErrorWithDataOptions.ts

@@ -0,0 +1,13 @@
+/**
+ * Type representing options object used when instantianting class returned from {@linkcode createCustomErrorWithData}.
+ */
+export type CustomErrorWithDataOptions<ErrorData> = {
+  /** Array of values that are used as parameters to generate the error message. */
+  messageParameters?: unknown[];
+
+  /** Used for setting `cause` property of an error instance that indicates the specific original cause of the error. */
+  cause?: unknown;
+
+  /** Custom data that will be attached to the error instance. */
+  data?: ErrorData;
+};

package/src/types.ts

@@ -1,2 +1,5 @@
 export * from './types/CustomError.js';
+export * from './types/CustomErrorOptions.js';
+export * from './types/CustomErrorWithData.js';
+export * from './types/CustomErrorWithDataOptions.js';
 export * from './types/ErrorMessages.js';

package/LICENSE

@@ -1,18 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Jakub Mazanec
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial
-portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
-OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.