@c15t/backend 1.0.5 → 1.2.0-canary.0

package/dist/pkgs/logger/console-formatter.d.ts

@@ -1,56 +0,0 @@
-import type { LogLevel } from './types';
-/**
- * ANSI color codes for terminal output formatting.
- *
- * @remarks
- * Used to add color and styling to log messages in terminal environments.
- *
- * @internal
- */
-export declare const colors: {
-    reset: string;
-    bright: string;
-    dim: string;
-    underscore: string;
-    blink: string;
-    reverse: string;
-    hidden: string;
-    fg: {
-        black: string;
-        red: string;
-        green: string;
-        yellow: string;
-        blue: string;
-        magenta: string;
-        cyan: string;
-        white: string;
-    };
-    bg: {
-        black: string;
-        red: string;
-        green: string;
-        yellow: string;
-        blue: string;
-        magenta: string;
-        cyan: string;
-        white: string;
-    };
-};
-/**
- * Mapping of log levels to their corresponding colors.
- *
- * @internal
- */
-export declare const levelColors: Record<LogLevel, string>;
-/**
- * Formats a log message with timestamp, level indicator, and styling.
- *
- * @param level - The severity level of the message
- * @param message - The message content to format
- * @param appName - Optional application name to include in the log prefix
- * @returns The formatted message string with ANSI color codes
- *
- * @internal
- */
-export declare const formatMessage: (level: LogLevel, message: string, appName?: string) => string;
-//# sourceMappingURL=console-formatter.d.ts.map

package/dist/pkgs/logger/console-formatter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"console-formatter.d.ts","sourceRoot":"","sources":["../../../src/pkgs/logger/console-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BlB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAMhD,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GACzB,OAAO,QAAQ,EACf,SAAS,MAAM,EACf,gBAAgB,KACd,MAOF,CAAC"}

package/dist/pkgs/logger/index.cjs

@@ -1,240 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    logResult: ()=>logResult,
-    levels: ()=>levels,
-    logger: ()=>logger_factory_logger,
-    logError: ()=>logResult,
-    logErrorAsync: ()=>logResultAsync,
-    createLogger: ()=>createLogger,
-    shouldPublishLog: ()=>shouldPublishLog,
-    logResultAsync: ()=>logResultAsync
-});
-const levels = [
-    'error',
-    'warn',
-    'info',
-    'success',
-    'debug'
-];
-function shouldPublishLog(currentLogLevel, logLevel) {
-    const currentLevelIndex = levels.indexOf(currentLogLevel);
-    const messageLevelIndex = levels.indexOf(logLevel);
-    if ('debug' === currentLogLevel) return 'debug' === logLevel;
-    return messageLevelIndex <= currentLevelIndex;
-}
-const colors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    dim: '\x1b[2m',
-    underscore: '\x1b[4m',
-    blink: '\x1b[5m',
-    reverse: '\x1b[7m',
-    hidden: '\x1b[8m',
-    fg: {
-        black: '\x1b[30m',
-        red: '\x1b[31m',
-        green: '\x1b[32m',
-        yellow: '\x1b[33m',
-        blue: '\x1b[34m',
-        magenta: '\x1b[35m',
-        cyan: '\x1b[36m',
-        white: '\x1b[37m'
-    },
-    bg: {
-        black: '\x1b[40m',
-        red: '\x1b[41m',
-        green: '\x1b[42m',
-        yellow: '\x1b[43m',
-        blue: '\x1b[44m',
-        magenta: '\x1b[45m',
-        cyan: '\x1b[46m',
-        white: '\x1b[47m'
-    }
-};
-const levelColors = {
-    info: colors.fg.blue,
-    success: colors.fg.green,
-    warn: colors.fg.yellow,
-    error: colors.fg.red,
-    debug: colors.fg.magenta
-};
-const formatMessage = (level, message, appName = 'c15t')=>{
-    const timestamp = new Date().toISOString();
-    return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[${appName}]:${colors.reset} ${message}`;
-};
-const api_namespaceObject = require("@opentelemetry/api");
-const LOGGER_TRACER_NAME = '@doubletie/logger';
-const LOG_LEVEL_TO_SPAN_STATUS = {
-    error: api_namespaceObject.SpanStatusCode.ERROR,
-    warn: api_namespaceObject.SpanStatusCode.OK,
-    info: api_namespaceObject.SpanStatusCode.OK,
-    success: api_namespaceObject.SpanStatusCode.OK,
-    debug: api_namespaceObject.SpanStatusCode.OK
-};
-const getTracer = (options)=>{
-    if (options?.telemetry?.tracer) return options.telemetry.tracer;
-    return api_namespaceObject.trace.getTracer(LOGGER_TRACER_NAME);
-};
-const createLogSpan = (level, message, args = [], options)=>{
-    if (options?.telemetry?.disabled) return null;
-    const tracer = getTracer(options);
-    const span = tracer.startSpan('log_entry', {
-        attributes: {
-            'log.level': level,
-            'log.message': message,
-            'log.has_args': args.length > 0,
-            ...options?.telemetry?.defaultAttributes || {}
-        }
-    });
-    if (args.length > 0 && 'object' == typeof args[0] && null !== args[0]) {
-        const data = args[0];
-        for (const [key, value] of Object.entries(data))if (null != value) span.setAttribute(`log.data.${key}`, String(value));
-    }
-    span.setStatus({
-        code: LOG_LEVEL_TO_SPAN_STATUS[level],
-        message: 'error' === level || 'warn' === level ? message : void 0
-    });
-    return span;
-};
-const withLogSpan = async (level, message, args, operation, options)=>{
-    const span = createLogSpan(level, message, args, options);
-    if (!span) return operation();
-    try {
-        const result = await operation();
-        return result;
-    } catch (error) {
-        span.setStatus({
-            code: api_namespaceObject.SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-        });
-        throw error;
-    } finally{
-        span.end();
-    }
-};
-const createLogger = (options)=>{
-    if (options && 'object' == typeof options && levels.every((level)=>'function' == typeof options[level])) return options;
-    const loggerOptions = options;
-    const enabled = loggerOptions?.disabled !== true;
-    const logLevel = loggerOptions?.level ?? 'error';
-    const appName = loggerOptions?.appName ?? 'c15t';
-    const logFunc = async (level, message, args = [])=>{
-        if (!enabled || !shouldPublishLog(logLevel, level)) return;
-        await withLogSpan(level, message, args, async ()=>{
-            const formattedMessage = formatMessage(level, message, appName);
-            if (!loggerOptions || 'function' != typeof loggerOptions.log) {
-                if ('error' === level) console.error(formattedMessage, ...args);
-                else if ('warn' === level) console.warn(formattedMessage, ...args);
-                else if ('info' === level) console.log(formattedMessage, ...args);
-                else if ('debug' === level) console.debug(formattedMessage, ...args);
-                else if ('success' === level) console.log(formattedMessage, ...args);
-                return;
-            }
-            loggerOptions.log('success' === level ? 'info' : level, message, ...args);
-        });
-    };
-    return Object.fromEntries(levels.map((level)=>[
-            level,
-            (...[message, ...args])=>logFunc(level, message, args).catch((error)=>{
-                    console.error('Logger error:', error);
-                })
-        ]));
-};
-const logger_factory_logger = createLogger();
-const logResult = (result, logger, message = 'Error occurred:')=>{
-    const tracer = getTracer();
-    const span = tracer.startSpan('log_result');
-    return result.mapErr((error)=>{
-        span.setAttributes({
-            'error.message': error.message,
-            'error.code': error.code,
-            'error.status': error.status,
-            'error.category': error.category,
-            'error.has_meta': !!error.meta
-        });
-        span.setStatus({
-            code: api_namespaceObject.SpanStatusCode.ERROR,
-            message: error.message
-        });
-        logger.error(`${message} ${error.message}`, {
-            code: error.code,
-            status: error.status,
-            meta: error.meta,
-            category: error.category,
-            stack: error.stack
-        });
-        span.end();
-        return error;
-    });
-};
-const logResultAsync = (resultAsync, logger, message = 'Error occurred:')=>{
-    const tracer = getTracer();
-    const span = tracer.startSpan('log_result_async');
-    return resultAsync.mapErr((error)=>{
-        span.setAttributes({
-            'error.message': error.message,
-            'error.code': error.code,
-            'error.status': error.status,
-            'error.category': error.category,
-            'error.has_meta': !!error.meta
-        });
-        span.setStatus({
-            code: api_namespaceObject.SpanStatusCode.ERROR,
-            message: error.message
-        });
-        logger.error(`${message} ${error.message}`, {
-            code: error.code,
-            status: error.status,
-            meta: error.meta,
-            category: error.category,
-            stack: error.stack
-        });
-        span.end();
-        return error;
-    });
-};
-exports.createLogger = __webpack_exports__.createLogger;
-exports.levels = __webpack_exports__.levels;
-exports.logError = __webpack_exports__.logError;
-exports.logErrorAsync = __webpack_exports__.logErrorAsync;
-exports.logResult = __webpack_exports__.logResult;
-exports.logResultAsync = __webpack_exports__.logResultAsync;
-exports.logger = __webpack_exports__.logger;
-exports.shouldPublishLog = __webpack_exports__.shouldPublishLog;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "createLogger",
-    "levels",
-    "logError",
-    "logErrorAsync",
-    "logResult",
-    "logResultAsync",
-    "logger",
-    "shouldPublishLog"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/pkgs/logger/index.d.ts

@@ -1,35 +0,0 @@
-/**
- * @packageDocumentation
- * DoubleTie Logger Package
- *
- * A lightweight, customizable logging utility for Node.js and TypeScript applications.
- * It provides structured logging capabilities, error logging utilities for the Result pattern,
- * and flexible configuration options.
- *
- * @remarks
- * This package is designed to work standalone or as part of the DoubleTie SDK.
- * It includes:
- * - Configurable log levels and filters
- * - Color-coded console output
- * - Error logging for Result/ResultAsync types from neverthrow
- * - Custom log handlers
- *
- * @example
- * ```ts
- * import { createLogger, logResult } from '@doubletie/logger';
- *
- * // Create a custom logger
- * const logger = createLogger({ level: 'debug', appName: 'c15t' });
- *
- * // Log messages at different levels
- * logger.info('Application started');
- * logger.debug('Initializing components', { component: 'database' });
- * logger.warn('Configuration missing, using defaults');
- * logger.error('Failed to connect', { retry: true });
- * ```
- */
-export type { LogLevel, Logger, LoggerOptions, LogEntry, LoggableError, } from './types';
-export { levels, shouldPublishLog, } from './log-levels';
-export { createLogger, logger, } from './logger-factory';
-export { logResult, logResultAsync, logResult as logError, logResultAsync as logErrorAsync, } from './result-logging';
-//# sourceMappingURL=index.d.ts.map

package/dist/pkgs/logger/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pkgs/logger/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,YAAY,EACX,QAAQ,EACR,MAAM,EACN,aAAa,EACb,QAAQ,EACR,aAAa,GACb,MAAM,SAAS,CAAC;AAGjB,OAAO,EACN,MAAM,EACN,gBAAgB,GAChB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACN,YAAY,EACZ,MAAM,GACN,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACN,SAAS,EACT,cAAc,EACd,SAAS,IAAI,QAAQ,EACrB,cAAc,IAAI,aAAa,GAC/B,MAAM,kBAAkB,CAAC"}

package/dist/pkgs/logger/index.js

@@ -1,185 +0,0 @@
-import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__ from "@opentelemetry/api";
-const levels = [
-    'error',
-    'warn',
-    'info',
-    'success',
-    'debug'
-];
-function shouldPublishLog(currentLogLevel, logLevel) {
-    const currentLevelIndex = levels.indexOf(currentLogLevel);
-    const messageLevelIndex = levels.indexOf(logLevel);
-    if ('debug' === currentLogLevel) return 'debug' === logLevel;
-    return messageLevelIndex <= currentLevelIndex;
-}
-const colors = {
-    reset: '\x1b[0m',
-    bright: '\x1b[1m',
-    dim: '\x1b[2m',
-    underscore: '\x1b[4m',
-    blink: '\x1b[5m',
-    reverse: '\x1b[7m',
-    hidden: '\x1b[8m',
-    fg: {
-        black: '\x1b[30m',
-        red: '\x1b[31m',
-        green: '\x1b[32m',
-        yellow: '\x1b[33m',
-        blue: '\x1b[34m',
-        magenta: '\x1b[35m',
-        cyan: '\x1b[36m',
-        white: '\x1b[37m'
-    },
-    bg: {
-        black: '\x1b[40m',
-        red: '\x1b[41m',
-        green: '\x1b[42m',
-        yellow: '\x1b[43m',
-        blue: '\x1b[44m',
-        magenta: '\x1b[45m',
-        cyan: '\x1b[46m',
-        white: '\x1b[47m'
-    }
-};
-const levelColors = {
-    info: colors.fg.blue,
-    success: colors.fg.green,
-    warn: colors.fg.yellow,
-    error: colors.fg.red,
-    debug: colors.fg.magenta
-};
-const formatMessage = (level, message, appName = 'c15t')=>{
-    const timestamp = new Date().toISOString();
-    return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[${appName}]:${colors.reset} ${message}`;
-};
-const LOGGER_TRACER_NAME = '@doubletie/logger';
-const LOG_LEVEL_TO_SPAN_STATUS = {
-    error: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.ERROR,
-    warn: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK,
-    info: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK,
-    success: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK,
-    debug: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK
-};
-const getTracer = (options)=>{
-    if (options?.telemetry?.tracer) return options.telemetry.tracer;
-    return __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.trace.getTracer(LOGGER_TRACER_NAME);
-};
-const createLogSpan = (level, message, args = [], options)=>{
-    if (options?.telemetry?.disabled) return null;
-    const tracer = getTracer(options);
-    const span = tracer.startSpan('log_entry', {
-        attributes: {
-            'log.level': level,
-            'log.message': message,
-            'log.has_args': args.length > 0,
-            ...options?.telemetry?.defaultAttributes || {}
-        }
-    });
-    if (args.length > 0 && 'object' == typeof args[0] && null !== args[0]) {
-        const data = args[0];
-        for (const [key, value] of Object.entries(data))if (null != value) span.setAttribute(`log.data.${key}`, String(value));
-    }
-    span.setStatus({
-        code: LOG_LEVEL_TO_SPAN_STATUS[level],
-        message: 'error' === level || 'warn' === level ? message : void 0
-    });
-    return span;
-};
-const withLogSpan = async (level, message, args, operation, options)=>{
-    const span = createLogSpan(level, message, args, options);
-    if (!span) return operation();
-    try {
-        const result = await operation();
-        return result;
-    } catch (error) {
-        span.setStatus({
-            code: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.ERROR,
-            message: error instanceof Error ? error.message : String(error)
-        });
-        throw error;
-    } finally{
-        span.end();
-    }
-};
-const createLogger = (options)=>{
-    if (options && 'object' == typeof options && levels.every((level)=>'function' == typeof options[level])) return options;
-    const loggerOptions = options;
-    const enabled = loggerOptions?.disabled !== true;
-    const logLevel = loggerOptions?.level ?? 'error';
-    const appName = loggerOptions?.appName ?? 'c15t';
-    const logFunc = async (level, message, args = [])=>{
-        if (!enabled || !shouldPublishLog(logLevel, level)) return;
-        await withLogSpan(level, message, args, async ()=>{
-            const formattedMessage = formatMessage(level, message, appName);
-            if (!loggerOptions || 'function' != typeof loggerOptions.log) {
-                if ('error' === level) console.error(formattedMessage, ...args);
-                else if ('warn' === level) console.warn(formattedMessage, ...args);
-                else if ('info' === level) console.log(formattedMessage, ...args);
-                else if ('debug' === level) console.debug(formattedMessage, ...args);
-                else if ('success' === level) console.log(formattedMessage, ...args);
-                return;
-            }
-            loggerOptions.log('success' === level ? 'info' : level, message, ...args);
-        });
-    };
-    return Object.fromEntries(levels.map((level)=>[
-            level,
-            (...[message, ...args])=>logFunc(level, message, args).catch((error)=>{
-                    console.error('Logger error:', error);
-                })
-        ]));
-};
-const logger_factory_logger = createLogger();
-const logResult = (result, logger, message = 'Error occurred:')=>{
-    const tracer = getTracer();
-    const span = tracer.startSpan('log_result');
-    return result.mapErr((error)=>{
-        span.setAttributes({
-            'error.message': error.message,
-            'error.code': error.code,
-            'error.status': error.status,
-            'error.category': error.category,
-            'error.has_meta': !!error.meta
-        });
-        span.setStatus({
-            code: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.ERROR,
-            message: error.message
-        });
-        logger.error(`${message} ${error.message}`, {
-            code: error.code,
-            status: error.status,
-            meta: error.meta,
-            category: error.category,
-            stack: error.stack
-        });
-        span.end();
-        return error;
-    });
-};
-const logResultAsync = (resultAsync, logger, message = 'Error occurred:')=>{
-    const tracer = getTracer();
-    const span = tracer.startSpan('log_result_async');
-    return resultAsync.mapErr((error)=>{
-        span.setAttributes({
-            'error.message': error.message,
-            'error.code': error.code,
-            'error.status': error.status,
-            'error.category': error.category,
-            'error.has_meta': !!error.meta
-        });
-        span.setStatus({
-            code: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.ERROR,
-            message: error.message
-        });
-        logger.error(`${message} ${error.message}`, {
-            code: error.code,
-            status: error.status,
-            meta: error.meta,
-            category: error.category,
-            stack: error.stack
-        });
-        span.end();
-        return error;
-    });
-};
-export { createLogger, levels, logResult as logError, logResultAsync as logErrorAsync, logResult, logResultAsync, logger_factory_logger as logger, shouldPublishLog };

package/dist/pkgs/logger/log-levels.d.ts

@@ -1,29 +0,0 @@
-import type { LogLevel } from './types';
-/**
- * Array of all available log levels in order of importance.
- *
- * @remarks
- * This const array ensures type safety when working with log levels
- * and provides a reference for level comparisons.
- *
- * @public
- */
-export declare const levels: readonly ["error", "warn", "info", "success", "debug"];
-/**
- * Determines if a log message should be published based on configured log level.
- *
- * @param currentLogLevel - The configured log level threshold for the logger
- * @param logLevel - The level of the message being evaluated
- * @returns Boolean indicating whether the message should be published
- *
- * @example
- * ```ts
- * // Only publish if error level is at or above the current log level
- * if (shouldPublishLog('warn', 'error')) {
- *   // This will return true as error is more severe than warn
- * }
- * ```
- * @public
- */
-export declare function shouldPublishLog(currentLogLevel: LogLevel, logLevel: LogLevel): boolean;
-//# sourceMappingURL=log-levels.d.ts.map

package/dist/pkgs/logger/log-levels.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log-levels.d.ts","sourceRoot":"","sources":["../../../src/pkgs/logger/log-levels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,wDAAyD,CAAC;AAE7E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC/B,eAAe,EAAE,QAAQ,EACzB,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAaT"}

package/dist/pkgs/logger/logger-factory.d.ts

@@ -1,42 +0,0 @@
-import type { Logger, LoggerOptions } from './types';
-/**
- * Creates a configured logger instance with methods for each log level.
- *
- * @param options - Configuration options for the logger or an existing logger instance
- * @returns An object with methods for each log level
- *
- * @example
- * ```ts
- * // Create a logger that only shows warnings and errors
- * const logger = createLogger({ level: 'warn', appName: 'c15t' });
- *
- * // These will be output
- * logger.error('This is an error');
- * logger.warn('This is a warning');
- *
- * // These will be suppressed
- * logger.info('This info won\'t be shown');
- * logger.debug('This debug message won\'t be shown');
- * ```
- *
- * @public
- */
-export declare const createLogger: (options?: LoggerOptions | Logger) => Logger;
-/**
- * Default logger instance with standard configuration.
- *
- * @remarks
- * Ready-to-use logger with default settings (logs errors only).
- *
- * @example
- * ```ts
- * import { logger } from '@doubletie/logger';
- *
- * logger.error('Something went wrong');
- * logger.info('This won\'t be shown with default settings');
- * ```
- *
- * @public
- */
-export declare const logger: Logger;
-//# sourceMappingURL=logger-factory.d.ts.map

package/dist/pkgs/logger/logger-factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger-factory.d.ts","sourceRoot":"","sources":["../../../src/pkgs/logger/logger-factory.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAsB,MAAM,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,YAAY,GAAI,UAAU,aAAa,GAAG,MAAM,KAAG,MA2E/D,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,QAAiB,CAAC"}

package/dist/pkgs/logger/result-logging.d.ts

@@ -1,71 +0,0 @@
-import type { Result, ResultAsync } from 'neverthrow';
-import type { LoggableError } from './types';
-/**
- * Logs any errors in a Result without changing the Result.
- *
- * @remarks
- * This utility function allows logging errors from a Result type without
- * affecting the Result's flow. It uses the mapErr function to extract
- * and log the error if present, then returns the original Result.
- *
- * @typeParam ValueType - The type of the successful value in the Result
- * @typeParam ErrorType - The type of the error in the Result, must extend LoggableError
- *
- * @param result - The Result that may contain an error
- * @param logger - Logger instance with an error method
- * @param message - Optional message prefix for the error
- * @returns The original Result unchanged
- *
- * @example
- * ```ts
- * import { logResult } from '@doubletie/logger';
- * import { createLogger } from '@doubletie/logger';
- * import { ok, err } from 'neverthrow';
- *
- * const logger = createLogger();
- * const result = err({ message: 'Failed operation', code: 'OP_FAILED' });
- *
- * // Log the error but continue processing the Result
- * const processedResult = logResult(result, logger);
- * ```
- *
- * @public
- */
-export declare const logResult: <ValueType, ErrorType extends LoggableError>(result: Result<ValueType, ErrorType>, logger: {
-    error: (message: string, ...args: unknown[]) => void;
-}, message?: string) => Result<ValueType, ErrorType>;
-/**
- * Logs any errors in a ResultAsync without changing the ResultAsync.
- *
- * @remarks
- * This utility function allows logging errors from a ResultAsync type without
- * affecting the ResultAsync's flow. It uses the mapErr function to extract
- * and log the error if present, then returns the original ResultAsync.
- *
- * @typeParam ValueType - The type of the successful value in the ResultAsync
- * @typeParam ErrorType - The type of the error in the ResultAsync, must extend LoggableError
- *
- * @param resultAsync - The ResultAsync that may contain an error
- * @param logger - Logger instance with an error method
- * @param message - Optional message prefix for the error
- * @returns The original ResultAsync unchanged
- *
- * @example
- * ```ts
- * import { logResultAsync } from '@doubletie/logger';
- * import { createLogger } from '@doubletie/logger';
- * import { okAsync, errAsync } from 'neverthrow';
- *
- * const logger = createLogger();
- * const resultAsync = errAsync({ message: 'Failed async operation', code: 'ASYNC_FAILED' });
- *
- * // Log the error but continue processing the ResultAsync
- * const processedResultAsync = logResultAsync(resultAsync, logger);
- * ```
- *
- * @public
- */
-export declare const logResultAsync: <ValueType, ErrorType extends LoggableError>(resultAsync: ResultAsync<ValueType, ErrorType>, logger: {
-    error: (message: string, ...args: unknown[]) => void;
-}, message?: string) => ResultAsync<ValueType, ErrorType>;
-//# sourceMappingURL=result-logging.d.ts.map

package/dist/pkgs/logger/result-logging.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result-logging.d.ts","sourceRoot":"","sources":["../../../src/pkgs/logger/result-logging.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,SAAS,GAAI,SAAS,EAAE,SAAS,SAAS,aAAa,EACnE,QAAQ,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,EACpC,QAAQ;IAAE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;CAAE,EAChE,gBAA2B,KACzB,MAAM,CAAC,SAAS,EAAE,SAAS,CA4B7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,EAAE,SAAS,SAAS,aAAa,EACxE,aAAa,WAAW,CAAC,SAAS,EAAE,SAAS,CAAC,EAC9C,QAAQ;IAAE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;CAAE,EAChE,gBAA2B,KACzB,WAAW,CAAC,SAAS,EAAE,SAAS,CA4BlC,CAAC"}