effect-errors 1.3.11 → 1.4.0

package/README.md

@@ -146,31 +146,35 @@ Effect.fail({ _tag: 'SucksToBeMe', message: 'Yeah...' });
 You might want to apply your own logic to reported errors data; for example if you want to display errors in html. You can do so using `captureErrors`. The function has the following signature:
 
 ```typescript
-export interface ErrorSpan {
+interface ErrorSpan {
   name: string;
   attributes: ReadonlyMap<string, unknown>;
   status: SpanStatus;
 }
 
-export interface ErrorData {
+interface ErrorData {
   errorType: unknown;
   message: unknown;
   stack?: string;
+  effectStacktrace?: string;
   spans?: ErrorSpan[];
   isPlainString: boolean;
 }
 
-export interface CapturedErrors {
+interface CapturedErrors {
   interrupted: boolean;
   errors: ErrorData[];
 }
 
-export interface CaptureErrorsOptions {
+interface CaptureErrorsOptions {
   reverseSpans?: boolean;
   stripCwd?: boolean;
 }
 
-type captureErrorsFunction: <E>(cause: Cause<E>, options: CaptureErrorsOptions) => CapturedErrors
+const captureErrors: <E>(
+  cause: Cause<E>,
+  { reverseSpans, stripCwd }?: CaptureErrorsOptions,
+) => CapturedErrors;
 ```
 
 You can use `captureErrors` like so:

package/capture-errors.d.ts

@@ -9,6 +9,7 @@ export interface ErrorData {
     errorType: unknown;
     message: unknown;
     stack?: string;
+    effectStacktrace?: string;
     spans?: ErrorSpan[];
     isPlainString: boolean;
 }

package/capture-errors.js

@@ -1,9 +1,35 @@
 "use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.captureErrors = void 0;
 var effect_1 = require("effect");
 var Cause_1 = require("effect/Cause");
 var capture_errors_from_cause_1 = require("./logic/errors/capture-errors-from-cause");
+var split_spans_attributes_by_type_1 = require("./logic/spans/split-spans-attributes-by-type");
 var strip_cwd_path_1 = require("./logic/strip-cwd-path");
 var captureErrors = function (cause, _a) {
     var _b = _a === void 0 ? {
@@ -18,11 +44,14 @@ var captureErrors = function (cause, _a) {
     }
     var errors = (0, capture_errors_from_cause_1.captureErrorsFrom)(cause).map(function (_a) {
         var message = _a.message, maybeStack = _a.stack, span = _a.span, errorType = _a.errorType, isPlainString = _a.isPlainString;
+        var effectStacktrace = [];
         var spans = [];
         if (span !== undefined) {
             var current = span;
             while (current !== undefined && current._tag === 'Span') {
-                var name_1 = current.name, attributes = current.attributes, status_1 = current.status;
+                var name_1 = current.name, allAttributes = current.attributes, status_1 = current.status;
+                var _b = (0, split_spans_attributes_by_type_1.splitSpansAttributesByTypes)(allAttributes), attributes = _b.attributes, stacktrace = _b.stacktrace;
+                effectStacktrace.push.apply(effectStacktrace, __spreadArray([], __read(stacktrace), false));
                 spans.push({
                     name: name_1,
                     attributes: attributes,
@@ -39,6 +68,9 @@ var captureErrors = function (cause, _a) {
             errorType: errorType,
             message: message,
             stack: stack,
+            effectStacktrace: effectStacktrace.length > 0
+                ? effectStacktrace.join('\r\n')
+                : undefined,
             spans: reverseSpans === true ? spans.toReversed() : spans,
             isPlainString: isPlainString,
         };

package/capture-errors.test.js

@@ -47,7 +47,7 @@ void (0, console_mock_1.mockConsole)({
 });
 (0, vitest_1.describe)('captureErrors function', function () {
     (0, vitest_1.it)('should capture errors from promises', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var cause, result, _a, errorType, isPlainString, message, spans, stack;
+        var cause, result, _a, errorType, isPlainString, message, spans, effectStacktrace, stack;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0: return [4 /*yield*/, (0, effect_cause_1.effectCause)(from_promise_1.fromPromiseTask)];
@@ -59,7 +59,7 @@ void (0, console_mock_1.mockConsole)({
                     });
                     (0, vitest_1.expect)(result.interrupted).toBe(false);
                     (0, vitest_1.expect)(result.errors).toHaveLength(1);
-                    _a = result.errors[0], errorType = _a.errorType, isPlainString = _a.isPlainString, message = _a.message, spans = _a.spans, stack = _a.stack;
+                    _a = result.errors[0], errorType = _a.errorType, isPlainString = _a.isPlainString, message = _a.message, spans = _a.spans, effectStacktrace = _a.effectStacktrace, stack = _a.stack;
                     (0, vitest_1.expect)(errorType).toBe('FetchError');
                     (0, vitest_1.expect)(isPlainString).toBe(false);
                     (0, vitest_1.expect)(message.toString()).toStrictEqual('TypeError: fetch failed');
@@ -73,6 +73,7 @@ void (0, console_mock_1.mockConsole)({
                     ]);
                     (0, vitest_1.expect)(spans === null || spans === void 0 ? void 0 : spans[1].attributes).toHaveAttributes([]);
                     (0, vitest_1.expect)(stack).not.toHaveLength(0);
+                    (0, vitest_1.expect)(effectStacktrace).toContain('at fetchTask');
                     return [2 /*return*/];
             }
         });
@@ -113,6 +114,8 @@ void (0, console_mock_1.mockConsole)({
                     ]);
                     (0, vitest_1.expect)((_e = firstError.spans) === null || _e === void 0 ? void 0 : _e[2].name).toBe('withParallelErrorsTask');
                     (0, vitest_1.expect)((_f = firstError.spans) === null || _f === void 0 ? void 0 : _f[2].attributes).toHaveAttributes([]);
+                    (0, vitest_1.expect)(firstError.effectStacktrace).toContain('at readUser');
+                    (0, vitest_1.expect)(firstError.effectStacktrace).toContain('at parallelGet');
                     secondError = result.errors[1];
                     (0, vitest_1.expect)(secondError.errorType).toBe('UserNotFound');
                     (0, vitest_1.expect)(secondError.isPlainString).toBe(false);
@@ -134,6 +137,8 @@ void (0, console_mock_1.mockConsole)({
                     ]);
                     (0, vitest_1.expect)((_l = secondError.spans) === null || _l === void 0 ? void 0 : _l[2].name).toBe('withParallelErrorsTask');
                     (0, vitest_1.expect)((_m = secondError.spans) === null || _m === void 0 ? void 0 : _m[2].attributes).toHaveAttributes([]);
+                    (0, vitest_1.expect)(secondError.effectStacktrace).toContain('at readUser');
+                    (0, vitest_1.expect)(secondError.effectStacktrace).toContain('at parallelGet');
                     thirdError = result.errors[2];
                     (0, vitest_1.expect)(thirdError.errorType).toBe('UserNotFound');
                     (0, vitest_1.expect)(thirdError.isPlainString).toBe(false);
@@ -155,6 +160,8 @@ void (0, console_mock_1.mockConsole)({
                     ]);
                     (0, vitest_1.expect)((_s = thirdError.spans) === null || _s === void 0 ? void 0 : _s[2].name).toBe('withParallelErrorsTask');
                     (0, vitest_1.expect)((_t = thirdError.spans) === null || _t === void 0 ? void 0 : _t[2].attributes).toHaveAttributes([]);
+                    (0, vitest_1.expect)(thirdError.effectStacktrace).toContain('at readUser');
+                    (0, vitest_1.expect)(thirdError.effectStacktrace).toContain('at parallelGet');
                     return [2 /*return*/];
             }
         });

package/examples/from-promise.js

@@ -63,11 +63,7 @@ var readUser = effect_1.Effect.withSpan('readUser')(effect_1.Effect.tryPromise({
     catch: function (e) { return new file_error_1.FileError({ cause: e }); },
 }));
 var fetchTask = function (userId) {
-    return effect_1.Effect.withSpan('fetchUser', {
-        attributes: {
-            userId: userId,
-        },
-    })(effect_1.Effect.tryPromise({
+    return effect_1.Effect.withSpan('fetchUser', { attributes: { userId: userId } })(effect_1.Effect.tryPromise({
         try: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, fetch("https://yolo-bro-oh-no.org/users/".concat(userId))];

package/logic/spans/get-span-attributes.d.ts

@@ -1 +1,4 @@
-export declare const getSpanAttributes: (attributes: ReadonlyMap<string, unknown>, isLastEntry: boolean) => string;
+export declare const getSpanAttributes: (allAttributes: ReadonlyMap<string, unknown>, isLastEntry: boolean) => {
+    formattedAttributes: string;
+    stack: string[];
+};

package/logic/spans/get-span-attributes.js

@@ -21,16 +21,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSpanAttributes = void 0;
 var chalk_1 = __importDefault(require("chalk"));
-var getSpanAttributes = function (attributes, isLastEntry) {
-    if (attributes.size === 0) {
-        return '';
+var split_spans_attributes_by_type_1 = require("./split-spans-attributes-by-type");
+var maybePrintPipe = function (isLastEntry) {
+    return isLastEntry ? ' ' : chalk_1.default.gray('│');
+};
+var getSpanAttributes = function (allAttributes, isLastEntry) {
+    if (allAttributes.size === 0) {
+        return { formattedAttributes: '', stack: [] };
     }
-    var formattedAttributes = Array.from(attributes.entries())
+    var _a = (0, split_spans_attributes_by_type_1.splitSpansAttributesByTypes)(allAttributes), attributes = _a.attributes, stacktrace = _a.stacktrace;
+    var formattedAttributes = Array.from(attributes)
         .map(function (_a) {
         var _b = __read(_a, 2), key = _b[0], value = _b[1];
-        return "".concat(isLastEntry ? ' ' : chalk_1.default.gray('│'), "     ").concat(chalk_1.default.blue(key)).concat(chalk_1.default.gray(':'), " ").concat(value);
+        return "".concat(maybePrintPipe(isLastEntry), "     ").concat(chalk_1.default.blue(key)).concat(chalk_1.default.gray(':'), " ").concat(value);
     })
         .join('\r\n');
-    return "\r\n".concat(formattedAttributes);
+    return {
+        formattedAttributes: "\r\n".concat(formattedAttributes),
+        stack: stacktrace,
+    };
 };
 exports.getSpanAttributes = getSpanAttributes;

package/logic/spans/split-spans-attributes-by-type.d.ts

@@ -0,0 +1,6 @@
+interface FilteredEffectAttributes {
+    stacktrace: string[];
+    attributes: ReadonlyMap<string, unknown>;
+}
+export declare const splitSpansAttributesByTypes: (attributes: ReadonlyMap<string, unknown>) => FilteredEffectAttributes;
+export {};

package/logic/spans/split-spans-attributes-by-type.js

@@ -0,0 +1,47 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSpansAttributesByTypes = void 0;
+var splitSpansAttributesByTypes = function (attributes) {
+    return Array.from(attributes.entries()).reduce(function (prev, _a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        if (key === 'code.stacktrace') {
+            return {
+                attributes: prev.attributes,
+                stacktrace: __spreadArray(__spreadArray([], __read(prev.stacktrace), false), [value], false),
+            };
+        }
+        return {
+            attributes: new Map(__spreadArray(__spreadArray([], __read(prev.attributes), false), [[key, value]], false)),
+            stacktrace: prev.stacktrace,
+        };
+    }, {
+        stacktrace: [],
+        attributes: new Map(),
+    });
+};
+exports.splitSpansAttributesByTypes = splitSpansAttributesByTypes;

package/package.json

@@ -2,7 +2,7 @@
   "repository": "https://github.com/jpb06/effect-errors.git",
   "main": "index.js",
   "name": "effect-errors",
-  "version": "1.3.11",
+  "version": "1.4.0",
   "author": "jpb06 <jp.bois.06@outlook.fr>",
   "description": "A POC for errors reporting in Effect",
   "keywords": [],
@@ -27,39 +27,39 @@
     "run-examples": "bun run ./src/examples/util/run-all"
   },
   "dependencies": {
-    "@effect/schema": "^0.66.14",
+    "@effect/schema": "^0.67.9",
     "chalk": "<5",
-    "effect": "^3.1.2"
+    "effect": "^3.2.1"
   },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.0.2",
-    "@eslint/js": "^9.2.0",
-    "@stylistic/eslint-plugin": "^1.8.1",
-    "@stylistic/eslint-plugin-ts": "^1.8.1",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.3.0",
+    "@stylistic/eslint-plugin": "^2.1.0",
+    "@stylistic/eslint-plugin-ts": "^2.1.0",
     "@types/eslint": "^8.56.10",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^20.12.10",
-    "@typescript-eslint/eslint-plugin": "^7.8.0",
-    "@typescript-eslint/parser": "^7.8.0",
+    "@types/node": "^20.12.12",
+    "@typescript-eslint/eslint-plugin": "^7.9.0",
+    "@typescript-eslint/parser": "^7.9.0",
     "@vitest/coverage-v8": "^1.6.0",
     "copyfiles": "^2.4.1",
     "del-cli": "^5.1.0",
-    "eslint": "^9.2.0",
+    "eslint": "^9.3.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard-with-typescript": "^43.0.1",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-markdown": "^5.0.0",
-    "eslint-plugin-n": "^17.5.1",
+    "eslint-plugin-n": "^17.7.0",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-vitest": "^0.5.4",
     "fs-extra": "^11.2.0",
-    "globals": "^15.1.0",
+    "globals": "^15.3.0",
     "prettier": "^3.2.5",
     "readme-package-icons": "^1.1.14",
     "typescript": "*",
-    "typescript-eslint": "^7.8.0",
+    "typescript-eslint": "^7.9.0",
     "vitest": "^1.6.0",
     "vitest-mock-extended": "^1.3.1"
   }

package/pretty-print.js

@@ -1,4 +1,29 @@
 "use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -35,6 +60,7 @@ var prettyPrint = function (cause, _a) {
         if (isPlainString) {
             message += "\r\n".concat(chalk_1.default.gray('ℹ️  You used a plain string to represent a failure in the error channel (E). You should consider using tagged objects (with a _tag field), or yieldable errors such as Data.TaggedError and Schema.TaggedError for better handling experience.'));
         }
+        var spanAttributesStack = [];
         if (span !== undefined) {
             var current = span;
             var spans_1 = [];
@@ -49,21 +75,27 @@ var prettyPrint = function (cause, _a) {
                 var isFirstEntry = index === 0;
                 var isLastEntry = index === spans_1.length - 1;
                 var filePath = " at ".concat(stripCwd !== undefined ? (0, strip_cwd_path_1.stripCwdPath)(name) : name);
+                var _b = (0, get_span_attributes_1.getSpanAttributes)(attributes, isLastEntry), formattedAttributes = _b.formattedAttributes, stack = _b.stack;
+                spanAttributesStack.push.apply(spanAttributesStack, __spreadArray([], __read(stack), false));
                 return chalk_1.default.whiteBright((isFirstEntry ? "\r\n".concat(chalk_1.default.gray('◯')) : '') +
                     '\r\n' +
                     (0, spans_stack_trailing_char_1.spanStackTrailingChar)(isLastEntry) +
                     chalk_1.default.gray('─') +
                     filePath +
                     (0, get_span_duration_1.getSpanDuration)(status, isLastEntry) +
-                    (0, get_span_attributes_1.getSpanAttributes)(attributes, isLastEntry));
+                    formattedAttributes);
             })
                 .join('');
         }
         else if (!isPlainString) {
             message += "\r\n".concat(chalk_1.default.gray('ℹ️  Consider using spans to improve errors reporting.\r\n'));
         }
+        if (spanAttributesStack.length > 0) {
+            var cleanedStack = "\u2502 ".concat((0, filter_stack_1.filterStack)(spanAttributesStack.join('\r\n│ '), stripCwd === true));
+            message += "\r\n\uD83D\uDEA8 Effect Stacktrace\r\n".concat(chalk_1.default.red(cleanedStack));
+        }
         if (stack !== undefined) {
-            message += "\r\n".concat(span !== undefined ? '\r\n' : '', "\uD83D\uDEA8 Stacktrace\r\n").concat(chalk_1.default.red((0, filter_stack_1.filterStack)(stack, stripCwd === true)));
+            message += "\r\n".concat(span !== undefined ? '\r\n' : '', "\uD83D\uDEA8 Node Stacktrace\r\n").concat(chalk_1.default.red((0, filter_stack_1.filterStack)(stack, stripCwd === true)));
         }
         else if (!isPlainString) {
             message += "\r\n\r\n".concat(chalk_1.default.gray('ℹ️  Consider using a yieldable error such as Data.TaggedError and Schema.TaggedError to get a stacktrace.'));