@rotomeca/rop 5.0.2 → 6.0.0

package/dist/cjs/src/classes/abstracts/ATresult.js

@@ -41,5 +41,14 @@ class ATresult {
     static Fail(error) {
         return internal_1.Fail.Create(error ?? new Error("An error occurred"));
     }
+    /**
+     * Throw an error from an Error object or a text.
+     * @param error Error to throw
+     * @throws An Error
+     */
+    static Throw(error = undefined) {
+        const err = typeof error === 'string' ? new Error(error) : error;
+        this.Fail(err).throwIfError();
+    }
 }
 exports.ATresult = ATresult;

package/dist/cjs/src/decorators/LogOnError.js

@@ -0,0 +1,52 @@
+"use strict";
+// type: decorators
+// description: Decorators to log exceptions with a specific format before re-throwing them.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogOnError = LogOnError;
+exports.LogOnErrorAsync = LogOnErrorAsync;
+/**
+ * Decorator to log errors occurring during the execution of a synchronous method.
+ * Logs the error in the format: ### [methodName]what
+ * * @param logger - The logger function to use (default: console.error).
+ * @returns A method decorator that logs errors and re-throws them.
+ */
+function LogOnError(logger = console.error) {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("LogOnError can only be applied to methods.");
+        }
+        const methodName = String(context.name);
+        return function (...args) {
+            try {
+                return originalMethod.call(this, ...args);
+            }
+            catch (error) {
+                logger(`### [${methodName}]${error}`);
+                throw error;
+            }
+        };
+    };
+}
+/**
+ * Decorator to log errors occurring during the execution of an asynchronous method.
+ * Logs the error in the format: ### [methodName]what
+ * * @param logger - The logger function to use (default: console.error).
+ * @returns A method decorator that logs errors and re-throws them.
+ */
+function LogOnErrorAsync(logger = console.error) {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("LogOnErrorAsync can only be applied to methods.");
+        }
+        const methodName = String(context.name);
+        return async function (...args) {
+            try {
+                return await originalMethod.call(this, ...args);
+            }
+            catch (error) {
+                logger(`### [${methodName}]${error}`);
+                throw error;
+            }
+        };
+    };
+}

package/dist/esm/src/classes/abstracts/ATresult.d.ts

@@ -87,4 +87,21 @@ export declare abstract class ATresult<Success, E = Error> implements ITResult<S
      * @returns A new Fail instance containing the error.
      */
     static Fail<TSuccess, TE = Error>(error?: TE): ITResult<TSuccess, TE>;
+    /**
+     * Throw an error from a text.
+     * @param msg Error text
+     * @throws The created error
+     */
+    static Throw(msg: string): void;
+    /**
+     * Throw an error
+     * @param error Error to throw
+     * @throws The error
+     */
+    static Throw<TE extends Error>(error: TE): void;
+    /**
+     * Throw an error
+     * @throws An error
+     */
+    static Throw(): void;
 }

package/dist/esm/src/classes/abstracts/ATresult.js

@@ -38,4 +38,13 @@ export class ATresult {
     static Fail(error) {
         return Fail.Create(error ?? new Error("An error occurred"));
     }
+    /**
+     * Throw an error from an Error object or a text.
+     * @param error Error to throw
+     * @throws An Error
+     */
+    static Throw(error = undefined) {
+        const err = typeof error === 'string' ? new Error(error) : error;
+        this.Fail(err).throwIfError();
+    }
 }

package/dist/esm/src/decorators/LogOnError.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Type définition for a logger function.
+ */
+type LoggerFunction = (message: string) => void;
+/**
+ * Decorator to log errors occurring during the execution of a synchronous method.
+ * Logs the error in the format: ### [methodName]what
+ * * @param logger - The logger function to use (default: console.error).
+ * @returns A method decorator that logs errors and re-throws them.
+ */
+export declare function LogOnError(logger?: LoggerFunction): (originalMethod: Function, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => any;
+/**
+ * Decorator to log errors occurring during the execution of an asynchronous method.
+ * Logs the error in the format: ### [methodName]what
+ * * @param logger - The logger function to use (default: console.error).
+ * @returns A method decorator that logs errors and re-throws them.
+ */
+export declare function LogOnErrorAsync(logger?: LoggerFunction): (originalMethod: Function, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => Promise<any>;
+export {};

package/dist/esm/src/decorators/LogOnError.js

@@ -0,0 +1,48 @@
+// type: decorators
+// description: Decorators to log exceptions with a specific format before re-throwing them.
+/**
+ * Decorator to log errors occurring during the execution of a synchronous method.
+ * Logs the error in the format: ### [methodName]what
+ * * @param logger - The logger function to use (default: console.error).
+ * @returns A method decorator that logs errors and re-throws them.
+ */
+export function LogOnError(logger = console.error) {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("LogOnError can only be applied to methods.");
+        }
+        const methodName = String(context.name);
+        return function (...args) {
+            try {
+                return originalMethod.call(this, ...args);
+            }
+            catch (error) {
+                logger(`### [${methodName}]${error}`);
+                throw error;
+            }
+        };
+    };
+}
+/**
+ * Decorator to log errors occurring during the execution of an asynchronous method.
+ * Logs the error in the format: ### [methodName]what
+ * * @param logger - The logger function to use (default: console.error).
+ * @returns A method decorator that logs errors and re-throws them.
+ */
+export function LogOnErrorAsync(logger = console.error) {
+    return function (originalMethod, context) {
+        if (context.kind !== "method") {
+            throw new Error("LogOnErrorAsync can only be applied to methods.");
+        }
+        const methodName = String(context.name);
+        return async function (...args) {
+            try {
+                return await originalMethod.call(this, ...args);
+            }
+            catch (error) {
+                logger(`### [${methodName}]${error}`);
+                throw error;
+            }
+        };
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rotomeca/rop",
-  "version": "5.0.2",
+  "version": "6.0.0",
   "type": "module", 
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",