@levrbet/shared 0.1.104 → 0.1.106

package/dist/esm/server/utils/tracing/wrap.module.with.tracing.d.ts

@@ -1,127 +0,0 @@
-import { type NextFunction } from "express";
-/**
- * Wraps an Express request handler with tracing instrumentation.
- *
- * This utility function is intended to be used as a higher-order function to add tracing capabilities
- * to any standard Express handler. It leverages the `traceFn` function to automatically trace the
- * execution of the wrapped handler, capturing relevant telemetry for observability and debugging.
- *
- * The wrapped handler maintains the original signature and supports both synchronous and asynchronous
- * handlers. Any errors thrown by the handler will propagate as usual, allowing Express error handling
- * middleware to function as expected.
- *
- * @template TReq - The type of the Express request object. Defaults to `Request`.
- * @template TRes - The type of the Express response object. Defaults to `Response`.
- * @param handler - The original Express handler function to be wrapped. It can be synchronous or return a Promise.
- * @returns A new Express-compatible handler function with tracing instrumentation applied.
- *
- * @example
- * ```typescript
- * app.get('/endpoint', wrapExpressHandler(async (req, res) => {
- *   // handler logic
- * }));
- * ```
- *
- * @remarks
- * - The `traceFn` function must be defined in the scope and should handle the tracing logic.
- * - This wrapper is transparent to the handler's logic and does not alter request or response objects.
- */
-export declare function wrapExpressHandler<TReq extends Request = Request, TRes extends Response = Response>(handler: (req: TReq, res: TRes, next?: NextFunction) => void | Promise<void>): (req: TReq, res: TRes, next?: NextFunction) => Promise<void>;
-/**
- * Wraps all function properties of a given module object with tracing logic.
- *
- * This utility iterates over each property of the provided module object. If a property is a function,
- * it replaces it with an async wrapper that invokes the original function within a tracing context
- * using `traceFn`. Non-function properties are copied as-is. The returned object preserves the original
- * module's shape and types.
- *
- * @typeParam T - The type of the module object whose functions will be wrapped.
- * @param module - The module object whose function properties should be wrapped with tracing.
- * @returns A new object with the same properties as the input module, where all function properties
- *          are wrapped with tracing logic.
- *
- * @remarks
- * - The tracing logic assumes that all function properties are asynchronous and return Promises.
- * - The original module object is not mutated; a new object is returned.
- * - Non-function properties are shallow-copied.
- *
- * @example
- * ```typescript
- * const tracedModule = wrapFunctionsWithTracing(myModule);
- * await tracedModule.someAsyncFunction();
- * ```
- */
-export declare function wrapFunctionsWithTracing<T extends object>(module: T): T;
-/**
- * Wraps a class method with tracing logic, supporting both synchronous and asynchronous functions.
- *
- * This decorator factory intercepts method calls, invoking the provided `traceFn` utility to record
- * tracing information for each invocation. It ensures that both synchronous and asynchronous methods
- * are traced uniformly by always passing a Promise to `traceFn`. The original method's `this` context
- * and arguments are preserved.
- *
- * @template This - The type of the class instance (`this`) the method belongs to.
- * @template Args - The tuple type representing the method's argument list.
- * @template Return - The return type of the original method.
- *
- * @param target - The original method to be wrapped and traced.
- * @param context - The decorator context, providing metadata such as the method name.
- * @returns A replacement method that wraps the original method with tracing logic.
- *
- * @remarks
- * - The tracing is performed by the `traceFn` utility, which is expected to handle both sync and async flows.
- * - The method name is extracted from the decorator context and passed as metadata to `traceFn`.
- * - This utility is intended for use as a method decorator in class-based modules.
- *
- * @example
- * ```typescript
- * class MyService {
- *   @traced
- *   async fetchData(id: string): Promise<Data> {
- *     // ...
- *   }
- * }
- * ```
- */
-export declare function traced<This, Args extends unknown[], Return>(target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>): (this: This, ...args: Args) => Return;
-type Constructor<T = object> = new (...args: any[]) => T;
-/**
- * A class decorator factory that wraps all methods of a given class with tracing logic.
- *
- * This higher-order function returns a new class that extends the provided `BaseClass`.
- * In the constructor of the new class, it iterates over all own property names of the prototype,
- * and for each method (excluding the constructor), it replaces the method with a wrapped version
- * that invokes the `traceFn` function. This enables automatic tracing of both async and sync methods.
- *
- * - Async methods are detected by checking if the method's constructor name is `"AsyncFunction"`.
- * - Both async and sync methods are wrapped such that their execution is traced, and the method name
- *   is passed as metadata to the tracing function.
- * - The original method's `this` context and arguments are preserved.
- *
- * @template TBase - The type of the base class to be extended and wrapped.
- * @param BaseClass - The class whose methods should be wrapped with tracing logic.
- * @returns A new class extending `BaseClass` with all methods wrapped for tracing.
- *
- * @example
- * ```typescript
- * @TracedClass
- * class MyService {
- *   async fetchData() { ... }
- *   calculate() { ... }
- * }
- * or
- * const TracedService = TracedClass(MyService);
- * const service = new TracedService();
- * // All method calls on `service` will be traced.
- * ```
- *
- * @remarks
- * - The `traceFn` function must be defined in the module scope and should accept a function to execute
- *   and an options object containing at least the method name.
- * - This decorator is intended for use in environments where method-level tracing is required for
- *   observability or debugging purposes.
- * - The decorator assumes that all methods are either synchronous or asynchronous functions.
- */
-export declare function TracedClass<TBase extends Constructor>(BaseClass: TBase): TBase;
-export {};
-//# sourceMappingURL=wrap.module.with.tracing.d.ts.map

package/dist/esm/server/utils/tracing/wrap.module.with.tracing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrap.module.with.tracing.d.ts","sourceRoot":"","sources":["../../../../../src/server/utils/tracing/wrap.module.with.tracing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAA;AAG3C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,SAAS,OAAO,GAAG,OAAO,EAAE,IAAI,SAAS,QAAQ,GAAG,QAAQ,EAC/F,OAAO,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,IAE9D,KAAK,IAAI,EAAE,KAAK,IAAI,EAAE,OAAO,YAAY,mBAK1D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAgBvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,IAAI,SAAS,OAAO,EAAE,EAAE,MAAM,EACvD,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,EAC7C,OAAO,EAAE,2BAA2B,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,IAI/C,MAAM,IAAI,EAAE,GAAG,MAAM,IAAI,KAAG,MAAM,CAWvE;AAID,KAAK,WAAW,CAAC,CAAC,GAAG,MAAM,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,WAAW,CAAC,KAAK,SAAS,WAAW,EAAE,SAAS,EAAE,KAAK,GAAG,KAAK,CAwC9E"}

package/dist/esm/server/utils/tracing/wrap.module.with.tracing.js

@@ -1,196 +0,0 @@
-import { traceFn } from "./trace";
-/**
- * Wraps an Express request handler with tracing instrumentation.
- *
- * This utility function is intended to be used as a higher-order function to add tracing capabilities
- * to any standard Express handler. It leverages the `traceFn` function to automatically trace the
- * execution of the wrapped handler, capturing relevant telemetry for observability and debugging.
- *
- * The wrapped handler maintains the original signature and supports both synchronous and asynchronous
- * handlers. Any errors thrown by the handler will propagate as usual, allowing Express error handling
- * middleware to function as expected.
- *
- * @template TReq - The type of the Express request object. Defaults to `Request`.
- * @template TRes - The type of the Express response object. Defaults to `Response`.
- * @param handler - The original Express handler function to be wrapped. It can be synchronous or return a Promise.
- * @returns A new Express-compatible handler function with tracing instrumentation applied.
- *
- * @example
- * ```typescript
- * app.get('/endpoint', wrapExpressHandler(async (req, res) => {
- *   // handler logic
- * }));
- * ```
- *
- * @remarks
- * - The `traceFn` function must be defined in the scope and should handle the tracing logic.
- * - This wrapper is transparent to the handler's logic and does not alter request or response objects.
- */
-export function wrapExpressHandler(handler) {
-    return async (req, res, next) => {
-        return traceFn(async () => {
-            await handler(req, res, next);
-        });
-    };
-}
-/**
- * Wraps all function properties of a given module object with tracing logic.
- *
- * This utility iterates over each property of the provided module object. If a property is a function,
- * it replaces it with an async wrapper that invokes the original function within a tracing context
- * using `traceFn`. Non-function properties are copied as-is. The returned object preserves the original
- * module's shape and types.
- *
- * @typeParam T - The type of the module object whose functions will be wrapped.
- * @param module - The module object whose function properties should be wrapped with tracing.
- * @returns A new object with the same properties as the input module, where all function properties
- *          are wrapped with tracing logic.
- *
- * @remarks
- * - The tracing logic assumes that all function properties are asynchronous and return Promises.
- * - The original module object is not mutated; a new object is returned.
- * - Non-function properties are shallow-copied.
- *
- * @example
- * ```typescript
- * const tracedModule = wrapFunctionsWithTracing(myModule);
- * await tracedModule.someAsyncFunction();
- * ```
- */
-export function wrapFunctionsWithTracing(module) {
-    const wrapped = {};
-    for (const key of Object.keys(module)) {
-        const value = module[key];
-        if (typeof value === "function") {
-            wrapped[key] = (async (...args) => {
-                return traceFn(() => value(...args));
-            });
-        }
-        else {
-            wrapped[key] = value;
-        }
-    }
-    return wrapped;
-}
-/**
- * Wraps a class method with tracing logic, supporting both synchronous and asynchronous functions.
- *
- * This decorator factory intercepts method calls, invoking the provided `traceFn` utility to record
- * tracing information for each invocation. It ensures that both synchronous and asynchronous methods
- * are traced uniformly by always passing a Promise to `traceFn`. The original method's `this` context
- * and arguments are preserved.
- *
- * @template This - The type of the class instance (`this`) the method belongs to.
- * @template Args - The tuple type representing the method's argument list.
- * @template Return - The return type of the original method.
- *
- * @param target - The original method to be wrapped and traced.
- * @param context - The decorator context, providing metadata such as the method name.
- * @returns A replacement method that wraps the original method with tracing logic.
- *
- * @remarks
- * - The tracing is performed by the `traceFn` utility, which is expected to handle both sync and async flows.
- * - The method name is extracted from the decorator context and passed as metadata to `traceFn`.
- * - This utility is intended for use as a method decorator in class-based modules.
- *
- * @example
- * ```typescript
- * class MyService {
- *   @traced
- *   async fetchData(id: string): Promise<Data> {
- *     // ...
- *   }
- * }
- * ```
- */
-export function traced(target, context) {
-    const methodName = String(context.name);
-    return function replacementMethod(...args) {
-        // Handle both sync and async functions
-        const result = target.call(this, ...args);
-        if (result instanceof Promise) {
-            return traceFn(() => result, { method: methodName });
-        }
-        else {
-            // If it's a synchronous function, we can still trace it
-            return traceFn(() => Promise.resolve(result), { method: methodName });
-        }
-    };
-}
-/**
- * A class decorator factory that wraps all methods of a given class with tracing logic.
- *
- * This higher-order function returns a new class that extends the provided `BaseClass`.
- * In the constructor of the new class, it iterates over all own property names of the prototype,
- * and for each method (excluding the constructor), it replaces the method with a wrapped version
- * that invokes the `traceFn` function. This enables automatic tracing of both async and sync methods.
- *
- * - Async methods are detected by checking if the method's constructor name is `"AsyncFunction"`.
- * - Both async and sync methods are wrapped such that their execution is traced, and the method name
- *   is passed as metadata to the tracing function.
- * - The original method's `this` context and arguments are preserved.
- *
- * @template TBase - The type of the base class to be extended and wrapped.
- * @param BaseClass - The class whose methods should be wrapped with tracing logic.
- * @returns A new class extending `BaseClass` with all methods wrapped for tracing.
- *
- * @example
- * ```typescript
- * @TracedClass
- * class MyService {
- *   async fetchData() { ... }
- *   calculate() { ... }
- * }
- * or
- * const TracedService = TracedClass(MyService);
- * const service = new TracedService();
- * // All method calls on `service` will be traced.
- * ```
- *
- * @remarks
- * - The `traceFn` function must be defined in the module scope and should accept a function to execute
- *   and an options object containing at least the method name.
- * - This decorator is intended for use in environments where method-level tracing is required for
- *   observability or debugging purposes.
- * - The decorator assumes that all methods are either synchronous or asynchronous functions.
- */
-export function TracedClass(BaseClass) {
-    return class extends BaseClass {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        constructor(...args) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            super(...args);
-            const prototype = Object.getPrototypeOf(this);
-            for (const key of Object.getOwnPropertyNames(prototype)) {
-                if (key === "constructor")
-                    continue;
-                const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
-                const method = descriptor?.value;
-                if (typeof method === "function" && method.constructor.name === "AsyncFunction") {
-                    const wrapped = async (...args) => {
-                        return traceFn(() => method.apply(this, args), { method: key });
-                    };
-                    Object.defineProperty(this, key, {
-                        value: wrapped,
-                        writable: true,
-                        configurable: true,
-                    });
-                }
-                else {
-                    // If it's not an async function, we can still trace it
-                    const wrapped = (...args) => {
-                        return traceFn(() => Promise.resolve(method.apply(this, args)), {
-                            method: key,
-                        });
-                    };
-                    Object.defineProperty(this, key, {
-                        value: wrapped,
-                        writable: true,
-                        configurable: true,
-                    });
-                }
-            }
-        }
-    };
-}
-//# sourceMappingURL=wrap.module.with.tracing.js.map

package/dist/esm/server/utils/tracing/wrap.module.with.tracing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wrap.module.with.tracing.js","sourceRoot":"","sources":["../../../../../src/server/utils/tracing/wrap.module.with.tracing.ts"],"names":[],"mappings":"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"}