feat: resolve source locations in error stacks

Author: ph-fritsche

src/conductor/ChromeTestConductor.ts

@@ -2,7 +2,6 @@ import puppeteer, { Page } from 'puppeteer-core'
 import { TestConductor } from './TestConductor'
 import { HttpReporterServer } from './HttpReporterServer'
 import { TestReporter } from './TestReporter'
-import { ErrorStackResolver } from './ErrorStackResolver'
 import { AbortablePromise } from '../util/AbortablePromise'
 
 export class ChromeTestConductor extends TestConductor {
@@ -11,7 +10,6 @@ export class ChromeTestConductor extends TestConductor {
         title?: string,
         setupFiles: URL[] = [],
         coverageVar = '__coverage__',
-        errorStackResolver = new ErrorStackResolver([]),
         readonly browser = puppeteer.launch({
             executablePath: '/usr/bin/chromium',
             headless: 'new',
@@ -24,11 +22,9 @@ export class ChromeTestConductor extends TestConductor {
         }),
     ) {
         super(title, setupFiles, coverageVar)
-
-        this.reporterServer = new HttpReporterServer(errorStackResolver)
     }
 
-    readonly reporterServer: HttpReporterServer
+    readonly reporterServer = new HttpReporterServer()
 
     async close(): Promise<void> {
         await Promise.all([

src/conductor/ErrorStackResolver.ts

@@ -1,72 +1,115 @@
+import { fileURLToPath } from 'node:url'
 import { RawSourceMap, SourceMapConsumer } from 'source-map'
 
 export type FileServer = {
     url: string
     getFile: (path: string) => Promise<string>
-    origin: string
+    origin?: string
 }
 
 export class ErrorStackResolver {
     constructor(
         readonly fileServers: Array<FileServer>,
-    ) {
-    }
+    ) {}
 
     async rewriteStack(
         stack: string,
     ) {
-        const re = /(?<pre>\s+at [^\n)]+\()(?<url>\w+:\/\/[^/?]*[^)]*):(?<line>\d+):(?<column>\d+)(?<post>\)$)/gm
-        let r: RegExpExecArray|null
-        // eslint-disable-next-line no-cond-assign
-        while ((r = re.exec(stack)) && r?.groups) {
-            const url = r.groups.url
-            const line = Number(r.groups.line)
-            const column = Number(r.groups.column)
-            for (const server of this.fileServers) {
-                if (url.startsWith(server.url) && (server.url.endsWith('/') || url[server.url.length] === '/')) {
-                    const subpath = trimStart(url.substring(server.url.length), '/')
-                    let subPathAndPos = `${subpath}:${line}:${column}`
+        for (let end = stack.length, start = end;
+            start = stack.lastIndexOf('\n', start - 1), start >= 0;
+            end = start
+        ) {
+            const l = stack.substring(start, end)
+            if (l === '\n') {
+                continue
+            }
+            const at = l.match(/^\s+at /)
+            if (!at) {
+                break
+            }
+            const m = l.match(/ \((?<file>[^)]+):(?<line>\d+):(?<column>\d+)\)$/)
+            if (!m?.groups || m.index === undefined) {
+                continue
+            }
 
-                    // TODO: handle errors when resolving code positions
+            const name = l.substring(at[0].length, m.index)
+            const {file, line, column} = m.groups
 
-                    const content = await server.getFile(subpath)
-                    const mapMatch = String(content).match(/\n\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,(?<encodedMap>[0-9a-zA-Z+/]+)\s*$/)
-                    if (mapMatch?.groups) {
-                        const map = JSON.parse(Buffer.from(mapMatch.groups.encodedMap, 'base64').toString('utf8')) as RawSourceMap
-                        const original = await SourceMapConsumer.with(map, null, consumer => {
-                            return consumer.originalPositionFor({ line, column })
-                        })
-                        if (original.source) {
-                            subPathAndPos = `${subpath.substring(0, subpath.length - map.file.length)}${original.source}:${String(original.line)}:${String(original.column)}`
-                        }
-                    }
-                    const newStackEntry = r.groups.pre
-                        + server.origin
-                        + (server.origin.endsWith('/') ? '' : '/')
-                        + subPathAndPos
-                        + r.groups.post
+            const server = this.getServer(file)
+            if (!server) {
+                continue
+            }
 
-                    stack = stack.substring(0, r.index)
-                        + newStackEntry
-                        + stack.substring(r.index + r[0].length)
+            const map = await server.getFile(server.path).then(
+                source => this.getSourceMap(source, file),
+                () => undefined,
+            )
 
-                    re.lastIndex += newStackEntry.length - r[0].length
+            let resolved = map
+                ? await SourceMapConsumer.with(map.raw, map.url, consumer => {
+                    return consumer.originalPositionFor({line: Number(line), column: Number(column)})
+                })
+                : undefined
 
-                    break
+            if (!resolved?.source) {
+                resolved = {
+                    source: server.origin
+                        ? server.origin + (server.origin.endsWith('/') ? '' : '/') + server.path
+                        : null,
+                    name: null,
+                    line: null,
+                    column: null,
                 }
             }
+
+            if (resolved.source?.startsWith('file://')) {
+                resolved.source = fileURLToPath(resolved.source)
+            }
+
+            stack = stack.substring(0, start)
+                + at[0]
+                + (resolved.name ?? name)
+                + ' ('
+                + (resolved.source ?? file)
+                + (resolved.line !== null && resolved.column !== null
+                    ? `:${resolved.line}:${resolved.column}`
+                    : `:${line}:${column}`
+                )
+                + ')'
+                + stack.substring(end)
         }
         return stack
     }
-}
 
-function trimStart(
-    str: string,
-    chars: string,
-) {
-    for (let i = 0; ; i++) {
-        if (i >= str.length || !chars.includes(str[i])) {
-            return str.substring(i)
+    protected getServer(
+        url: string,
+    ) {
+        for (const server of this.fileServers) {
+            const pre = server.url.endsWith('/') ? server.url : server.url + '/'
+            if (url.startsWith(pre)) {
+                return {
+                    origin: server.origin,
+                    getFile: (p: string) => server.getFile(p),
+                    path: url.substring(pre.length),
+                }
+            }
+        }
+    }
+
+    protected getSourceMap(
+        source: string,
+        sourceUrl: string,
+    ) {
+        const sourceMappingURL = source.match(/\n\/\/# sourceMappingURL=([^\n]+)\s*$/m)?.[1]
+
+        if (sourceMappingURL?.startsWith('data:application/json')) {
+            const encodedMap = sourceMappingURL.match(/^data:application\/json(?:;charset=[-\w]+)?;base64,(?<encoded>[0-9a-zA-Z+/]+)/)?.groups?.encoded
+            if (encodedMap) {
+                return {
+                    raw: JSON.parse(Buffer.from(encodedMap, 'base64').toString()) as RawSourceMap,
+                    url: sourceUrl,
+                }
+            }
         }
     }
 }

src/conductor/HttpReporterServer.ts

@@ -1,5 +1,4 @@
 import { createServer, IncomingMessage, ServerResponse } from 'http'
-import { ErrorStackResolver } from './ErrorStackResolver'
 import { TestCompleteData, TestErrorData, TestReporter, TestResultData, TestScheduleData } from './TestReporter'
 
 export type HttpReporterReport = {
@@ -13,7 +12,6 @@ export type HttpReporterReport = {
 
 export class HttpReporterServer {
     constructor(
-        public readonly errorStackResolver: ErrorStackResolver,
         protected readonly host = '127.0.0.1',
     ) {
         this.url = new Promise((res, rej) => this.http.listen(0, '127.0.0.1', () => {

src/conductor/NodeTestConductor.ts

@@ -5,7 +5,6 @@ import url from 'node:url'
 import { TestConductor } from './TestConductor'
 import { HttpReporterServer } from './HttpReporterServer'
 import { TestReporter } from './TestReporter'
-import { ErrorStackResolver } from './ErrorStackResolver'
 import { AbortablePromise } from '../util/AbortablePromise'
 
 const loaderPathEnv = 'ToolboxNodeLoadersPath'
@@ -24,14 +23,11 @@ export class NodeTestConductor extends TestConductor {
         title?: string,
         setupFiles: URL[] = [],
         coverageVar = '__coverage__',
-        errorStackResolver = new ErrorStackResolver([]),
     ) {
         super(title, setupFiles, coverageVar)
-
-        this.reporterServer = new HttpReporterServer(errorStackResolver)
     }
 
-    readonly reporterServer: HttpReporterServer
+    readonly reporterServer = new HttpReporterServer()
 
     async close(): Promise<void> {
         await this.reporterServer.close()

src/conductor/TestRun/TestError.ts

@@ -1,15 +1,16 @@
 import { TestHook } from './TestHook'
+import { XError } from '../../error/XError'
 
-export class TestError {
+export class TestError extends XError {
     constructor(
-        readonly error: Error|string,
+        error: Error|string,
         readonly hook?: TestHook,
-    ) {}
-
-    toString() {
-        return typeof this.error === 'string'
-            ? this.error
-            : this.error.stack ?? `${this.error.name}: ${this.error.message}`
+    ) {
+        if (typeof error === 'string') {
+            super('', error)
+        } else {
+            super(error.name, error.message, error.stack, error.cause)
+        }
     }
 }
 

src/conductor/TestRun/TestResult.ts

@@ -1,22 +1,25 @@
 import { TestResultType } from './enum'
+import { XError } from '../../error/XError'
 
 export class TestResult {
     constructor(
         readonly type: TestResultType,
-        readonly error?: Error|string,
+        error?: Error|string,
         readonly duration?: number,
-    ) {}
+    ) {
+        this.error = TestResultError.from(error)
+    }
+    readonly error
+}
 
-    getErrorAsString() {
-        if (!this.error) {
-            return ''
-        } else if (typeof this.error === 'string') {
-            return this.error
-        } else if (this.error.stack) {
-            return this.error.stack
-        } else {
-            return this.error.name + ': ' + this.error.message
+export class TestResultError extends XError {
+    static from(e?: Error|string) {
+        if (e === undefined) {
+            return undefined
+        } else if (typeof e === 'string') {
+            return new TestResultError('', e)
         }
+        return new TestResultError(e.name, e.message, e.stack, e.cause)
     }
 }
 

src/error/ErrorStackResolver.ts

@@ -0,0 +1,40 @@
+import { SourceLocation, StackEntry } from './XError'
+
+export type { SourceLocation }
+
+export interface SourceLocationResolver {
+    resolve(loc: SourceLocation): Promise<SourceLocation|undefined>|SourceLocation|undefined
+}
+
+export class ErrorStackResolver {
+    constructor(
+        public resolvers: SourceLocationResolver[],
+    ) {}
+
+    #results: Record<string, Promise<SourceLocation>> = {}
+
+    clear() {
+        this.#results = {}
+    }
+
+    async resolve(entry: StackEntry) {
+        if (!(entry.raw in this.#results)) {
+            const p = this.#doResolve(entry)
+            this.#results[entry.raw] = p
+        }
+
+        return await this.#results[entry.raw]
+    }
+
+    async #doResolve(entry: StackEntry) {
+        let loc: SourceLocation = {
+            file: entry.file,
+            position: entry.position,
+            name: entry.name,
+        }
+        for (const r of this.resolvers) {
+            loc = await r.resolve(loc) ?? loc
+        }
+        return loc
+    }
+}

src/error/PathResolver.ts

@@ -0,0 +1,24 @@
+import { SourceLocationResolver } from './ErrorStackResolver'
+import { SourceLocation } from './XError'
+
+export class PathResolver implements SourceLocationResolver {
+    constructor(
+        path: string,
+        resolved: string,
+    ) {
+        this.path = path + (path.endsWith('/') ? '' : '/')
+        this.resolved = resolved
+            ? resolved + (resolved.endsWith('/') ? '' : '/')
+            : ''
+    }
+    readonly path: string
+    readonly resolved: string
+
+    resolve(loc: SourceLocation) {
+        if (loc.file?.startsWith(this.path)) {
+            return { ...loc,
+                file: this.resolved + loc.file.substring(this.path.length),
+            }
+        }
+    }
+}