@flareapp/core 2.2.0 → 2.3.0

package/tests/api.test.ts

@@ -1,95 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-
-import { Api } from '../src/api';
-
-const minimalReport = {
-    exceptionClass: 'Error',
-    message: 'test',
-    seenAtUnixNano: 0,
-    stacktrace: [],
-    events: [],
-    attributes: {},
-};
-
-describe('Api.report', () => {
-    const api = new Api();
-
-    beforeEach(() => {
-        vi.spyOn(globalThis, 'fetch');
-    });
-
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    test('sends POST with correct headers', async () => {
-        vi.mocked(fetch).mockResolvedValue(new Response('', { status: 201 }));
-
-        await api.report(minimalReport, 'https://example.com/ingest', 'test-key', false);
-
-        expect(fetch).toHaveBeenCalledWith(
-            'https://example.com/ingest',
-            expect.objectContaining({
-                method: 'POST',
-                headers: expect.objectContaining({
-                    'X-Api-Token': 'test-key',
-                    'Content-Type': 'application/json',
-                    'X-Flare-Client-Version': '2',
-                }),
-            }),
-        );
-    });
-
-    test('does not log on 201 response', async () => {
-        vi.mocked(fetch).mockResolvedValue(new Response('', { status: 201 }));
-        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-        await api.report(minimalReport, 'https://example.com/ingest', 'test-key', false, true);
-
-        expect(errorSpy).not.toHaveBeenCalled();
-    });
-
-    test('logs on non-201 response only when debug is true', async () => {
-        vi.mocked(fetch).mockResolvedValue(new Response('', { status: 429 }));
-        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-        await api.report(minimalReport, 'https://example.com/ingest', 'test-key', false, false);
-        expect(errorSpy).not.toHaveBeenCalled();
-
-        await api.report(minimalReport, 'https://example.com/ingest', 'test-key', false, true);
-        expect(errorSpy).toHaveBeenCalledOnce();
-    });
-
-    test('swallows fetch rejection and logs when debug is true', async () => {
-        vi.mocked(fetch).mockRejectedValue(new TypeError('network error'));
-        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-        await api.report(minimalReport, 'https://example.com/ingest', 'test-key', false, true);
-
-        expect(errorSpy).toHaveBeenCalledOnce();
-    });
-
-    test('swallows fetch rejection silently when debug is false', async () => {
-        vi.mocked(fetch).mockRejectedValue(new TypeError('network error'));
-        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-        await api.report(minimalReport, 'https://example.com/ingest', 'test-key', false, false);
-
-        expect(errorSpy).not.toHaveBeenCalled();
-    });
-
-    test('uses empty string for null key', async () => {
-        vi.mocked(fetch).mockResolvedValue(new Response('', { status: 201 }));
-
-        await api.report(minimalReport, 'https://example.com/ingest', null, false);
-
-        expect(fetch).toHaveBeenCalledWith(
-            expect.any(String),
-            expect.objectContaining({
-                headers: expect.objectContaining({
-                    'X-Api-Token': '',
-                }),
-            }),
-        );
-    });
-});

package/tests/configure.test.ts

@@ -1,16 +0,0 @@
-import { expect, test } from 'vitest';
-
-import { Flare } from '../src';
-
-test('configure merges over defaults', () => {
-    const client = new Flare();
-    client.configure({ key: 'key', ingestUrl: 'https://example.test/v1/errors' });
-
-    expect(client.config.key).toBe('key');
-    expect(client.config.ingestUrl).toBe('https://example.test/v1/errors');
-});
-
-test('default ingestUrl points to production', () => {
-    const client = new Flare();
-    expect(client.config.ingestUrl).toBe('https://ingress.flareapp.io/v1/errors');
-});

package/tests/contextCollector.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { Api } from '../src/api';
-import { Flare } from '../src/Flare';
-import type { Config } from '../src/types';
-
-describe('Flare ContextCollector', () => {
-    it('merges collector output into report attributes', async () => {
-        const collector = vi.fn((_config: Config) => ({ 'custom.key': 'custom-value' }));
-        const api = new Api();
-        const sent: any[] = [];
-        api.report = (report: any) => {
-            sent.push(report);
-            return Promise.resolve();
-        };
-
-        const flare = new Flare(api, collector);
-        flare.light('test-key');
-        await flare.report(new Error('boom'));
-
-        expect(collector).toHaveBeenCalledTimes(1);
-        expect(sent[0].attributes['custom.key']).toBe('custom-value');
-    });
-
-    it('defaults to a no-op collector', async () => {
-        const api = new Api();
-        const sent: any[] = [];
-        api.report = (report: any) => {
-            sent.push(report);
-            return Promise.resolve();
-        };
-        const flare = new Flare(api);
-        flare.light('test-key');
-        await flare.report(new Error('boom'));
-        expect(sent.length).toBe(1);
-    });
-});

package/tests/convertToError.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { convertToError } from '../src';
-
-describe('convertToError', () => {
-    test('returns the same Error instance if given an Error', () => {
-        const error = new Error('original');
-
-        const result = convertToError(error);
-
-        expect(result).toBe(error);
-        expect(result.message).toBe('original');
-    });
-
-    test('returns Error subclass instances as-is', () => {
-        const error = new TypeError('type error');
-
-        const result = convertToError(error);
-
-        expect(result).toBe(error);
-        expect(result).toBeInstanceOf(TypeError);
-    });
-
-    test('wraps a string in an Error', () => {
-        const result = convertToError('something went wrong');
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.message).toBe('something went wrong');
-    });
-
-    test('wraps an empty string in an Error', () => {
-        const result = convertToError('');
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.message).toBe('');
-    });
-
-    test('wraps a number in an Error via String()', () => {
-        const result = convertToError(42);
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.message).toBe('42');
-    });
-
-    test('wraps null in an Error', () => {
-        const result = convertToError(null);
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.message).toBe('null');
-    });
-
-    test('wraps undefined in an Error', () => {
-        const result = convertToError(undefined);
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.message).toBe('undefined');
-    });
-
-    test('extracts message from objects with a message property', () => {
-        const result = convertToError({ message: 'Internal Error', status: 500 });
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.message).toBe('Internal Error');
-    });
-
-    test('preserves stack from objects with a stack property', () => {
-        const stack = 'Error: test\n    at load (+page.server.ts:10:15)';
-        const result = convertToError({ message: 'test', stack });
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.message).toBe('test');
-        expect(result.stack).toBe(stack);
-    });
-
-    test('preserves name from objects with a name property', () => {
-        const result = convertToError({ message: 'test', name: 'TypeError' });
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.name).toBe('TypeError');
-    });
-
-    test('wraps an object without message in an Error', () => {
-        const result = convertToError({ key: 'value' });
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.message).toBe('[object Object]');
-    });
-
-    test('wraps a boolean in an Error', () => {
-        const result = convertToError(false);
-
-        expect(result).toBeInstanceOf(Error);
-        expect(result.message).toBe('false');
-    });
-});

package/tests/createStackTrace.test.ts

@@ -1,54 +0,0 @@
-// @vitest-environment jsdom
-import ErrorStackParser from 'error-stack-parser';
-import { expect, test, vi } from 'vitest';
-
-import { createStackTrace } from '../src/stacktrace/createStackTrace';
-import { NullFileReader } from '../src/stacktrace/NullFileReader';
-
-vi.mock('error-stack-parser', () => ({
-    default: {
-        parse: vi.fn(() => {
-            throw new Error('parser broke on malformed stack');
-        }),
-    },
-}));
-
-const nullReader = new NullFileReader();
-
-test('resolves (does not reject) when ErrorStackParser throws', async () => {
-    const error = new Error('boom');
-    // ensure hasStack() returns true so we reach the parse call
-    error.stack = 'Error: boom\n    at fn (file.js:1:1)\n    at fn2 (file.js:2:2)';
-
-    await expect(createStackTrace(error, false, nullReader)).resolves.toBeDefined();
-});
-
-test('returns a fallback frame array when ErrorStackParser throws', async () => {
-    const error = new Error('boom');
-    error.stack = 'Error: boom\n    at fn (file.js:1:1)';
-
-    const frames = await createStackTrace(error, false, nullReader);
-
-    expect(Array.isArray(frames)).toBe(true);
-    expect(frames.length).toBeGreaterThan(0);
-});
-
-test('marks node_modules frames as non-application', async () => {
-    (ErrorStackParser.parse as unknown as ReturnType<typeof vi.fn>).mockImplementationOnce(() => [
-        {
-            fileName: 'https://cdn.test/app/node_modules/lodash/index.js',
-            lineNumber: 1,
-            columnNumber: 1,
-            functionName: 'lodash',
-        },
-        { fileName: 'https://cdn.test/app/src/main.ts', lineNumber: 2, columnNumber: 2, functionName: 'main' },
-    ]);
-
-    const error = new Error('boom');
-    error.stack = 'Error: boom\n    at fn (file.js:1:1)';
-
-    const frames = await createStackTrace(error, false, nullReader);
-
-    expect(frames[0].isApplicationFrame).toBe(false);
-    expect(frames[1].isApplicationFrame).toBe(true);
-});

package/tests/extractCode.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { extractCode } from '../src/util';
-
-describe('extractCode', () => {
-    test('returns string code from error', () => {
-        const err = Object.assign(new Error('boom'), { code: 'ENOTFOUND' });
-        expect(extractCode(err)).toBe('ENOTFOUND');
-    });
-
-    test('returns undefined when no code', () => {
-        expect(extractCode(new Error('boom'))).toBeUndefined();
-    });
-
-    test('returns undefined for non-string code (e.g. legacy Node errno number)', () => {
-        const err = Object.assign(new Error('boom'), { code: 42 });
-        expect(extractCode(err)).toBeUndefined();
-    });
-
-    test('returns undefined for empty string code', () => {
-        const err = Object.assign(new Error('boom'), { code: '' });
-        expect(extractCode(err)).toBeUndefined();
-    });
-
-    test('truncates code longer than 64 chars', () => {
-        const long = 'A'.repeat(100);
-        const err = Object.assign(new Error('boom'), { code: long });
-        expect(extractCode(err)).toBe('A'.repeat(64));
-    });
-});

package/tests/fileReader.test.ts

@@ -1,51 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-
-import { __clearFileReaderCacheForTests, getCodeSnippet, readLinesFromFile } from '../src/stacktrace/fileReader';
-import type { FileReader } from '../src/stacktrace/fileReader';
-
-class StubReader implements FileReader {
-    constructor(private map: Record<string, string | null>) {}
-    read(url: string): Promise<string | null> {
-        return Promise.resolve(this.map[url] ?? null);
-    }
-}
-
-describe('getCodeSnippet', () => {
-    beforeEach(() => __clearFileReaderCacheForTests());
-
-    it('returns an error message when url is missing', async () => {
-        const reader = new StubReader({});
-        const res = await getCodeSnippet(reader, undefined, 1, 1);
-        expect(res.codeSnippet[0]).toContain('missing file URL');
-    });
-
-    it('returns the line and surrounding context', async () => {
-        const reader = new StubReader({ 'a.js': 'a\nb\nc\nd\ne' });
-        const res = await getCodeSnippet(reader, 'a.js', 3, 1);
-        expect(res.codeSnippet[3]).toBe('c');
-        expect(res.codeSnippet[2]).toBe('b');
-        expect(res.codeSnippet[4]).toBe('d');
-    });
-
-    it('caches reads', async () => {
-        let calls = 0;
-        const reader: FileReader = {
-            read(_url: string) {
-                calls += 1;
-                return Promise.resolve('x\ny\nz');
-            },
-        };
-        await getCodeSnippet(reader, 'a.js', 2, 1);
-        await getCodeSnippet(reader, 'a.js', 2, 1);
-        expect(calls).toBe(1);
-    });
-});
-
-describe('readLinesFromFile', () => {
-    it('truncates very long lines from the start', () => {
-        const long = 'x'.repeat(2000);
-        const res = readLinesFromFile(long, 1);
-        expect(res.codeSnippet[1].length).toBeLessThanOrEqual(1001);
-        expect(res.codeSnippet[1].endsWith('…')).toBe(true);
-    });
-});

package/tests/flatJsonStringify.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { flatJsonStringify } from '../src/util';
-
-describe('flatJsonStringify', () => {
-    test('preserves shared (non-cyclic) sub-objects on both branches', () => {
-        const inner = { x: 1 };
-        const obj = { a: inner, b: inner };
-
-        const parsed = JSON.parse(flatJsonStringify(obj));
-
-        expect(parsed).toEqual({ a: { x: 1 }, b: { x: 1 } });
-    });
-
-    test('replaces real cycles with a sentinel rather than silently dropping the field', () => {
-        const obj: { a: number; self?: unknown } = { a: 1 };
-        obj.self = obj;
-
-        const parsed = JSON.parse(flatJsonStringify(obj));
-
-        expect(parsed.a).toBe(1);
-        expect(parsed.self).toBe('[Circular]');
-    });
-
-    test('does not throw on cyclic structures', () => {
-        const obj: { self?: unknown } = {};
-        obj.self = obj;
-
-        expect(() => flatJsonStringify(obj)).not.toThrow();
-    });
-});

package/tests/flush.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { Api } from '../src/api';
-import { Flare } from '../src/Flare';
-
-describe('Flare.flush', () => {
-    it('awaits in-flight reports', async () => {
-        let resolveApi: () => void = () => {};
-        const apiPromise = new Promise<void>((res) => {
-            resolveApi = res;
-        });
-        const api = new Api();
-        api.report = () => apiPromise;
-        const flare = new Flare(api);
-        flare.light('k');
-
-        let flushDone = false;
-        const reportPromise = flare.report(new Error('x'));
-        const flushPromise = flare.flush(1000).then(() => {
-            flushDone = true;
-        });
-
-        // flush should not resolve while the report is in flight
-        await new Promise((r) => setTimeout(r, 10));
-        expect(flushDone).toBe(false);
-
-        resolveApi();
-        await reportPromise;
-        await flushPromise;
-        expect(flushDone).toBe(true);
-    });
-
-    it('returns after timeout even if a report is stuck', async () => {
-        const api = new Api();
-        api.report = () => new Promise(() => {}); // never resolves
-        const flare = new Flare(api);
-        flare.light('k');
-        const reportPromise = flare.report(new Error('x'));
-        const start = Date.now();
-        await flare.flush(50);
-        const elapsed = Date.now() - start;
-        expect(elapsed).toBeGreaterThanOrEqual(45);
-        expect(elapsed).toBeLessThan(500);
-        // swallow the never-resolving promise
-        void reportPromise;
-    });
-});

package/tests/glows.test.ts

@@ -1,47 +0,0 @@
-// @vitest-environment jsdom
-import { beforeEach, expect, test } from 'vitest';
-
-import { Flare } from '../src';
-import { FakeApi } from './helpers';
-
-let fakeApi: FakeApi;
-let client: Flare;
-
-beforeEach(() => {
-    fakeApi = new FakeApi();
-    client = new Flare(fakeApi).configure({ key: 'key', debug: true });
-});
-
-test('glows are serialized into php_glow span events on report', async () => {
-    client.glow('rendering checkout', 'info', { cartId: 7 });
-
-    await client.reportMessage('hello');
-
-    const event = fakeApi.lastReport!.events[0];
-    expect(event.type).toBe('php_glow');
-    expect(event.endTimeUnixNano).toBeNull();
-    expect(typeof event.startTimeUnixNano).toBe('number');
-    expect(event.attributes['glow.name']).toBe('rendering checkout');
-    expect(event.attributes['glow.level']).toBe('info');
-    expect(event.attributes['glow.context']).toEqual({ cartId: 7 });
-});
-
-test('glow buffer respects maxGlowsPerReport', () => {
-    client.configure({ maxGlowsPerReport: 2 });
-    client.glow('a').glow('b').glow('c');
-
-    expect(client.glows).toHaveLength(2);
-    expect(client.glows.map((g) => g.name)).toEqual(['b', 'c']);
-});
-
-test('clearGlows empties the buffer', () => {
-    client.glow('a').glow('b');
-    client.clearGlows();
-
-    expect(client.glows).toHaveLength(0);
-});
-
-test('events array is empty when no glows recorded', async () => {
-    await client.report(new Error('x'));
-    expect(fakeApi.lastReport!.events).toEqual([]);
-});

package/tests/glowsToEvents.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, test } from 'vitest';
-
-import { glowsToEvents } from '../src/util';
-
-describe('glowsToEvents', () => {
-    test('produces a php_glow span event per glow', () => {
-        const events = glowsToEvents([
-            { name: 'rendering checkout', messageLevel: 'info', metaData: { cartId: 7 }, time: 1, microtime: 1 },
-        ]);
-
-        expect(events).toHaveLength(1);
-        expect(events[0]).toEqual({
-            type: 'php_glow',
-            startTimeUnixNano: 1_000_000_000,
-            endTimeUnixNano: null,
-            attributes: {
-                'glow.name': 'rendering checkout',
-                'glow.level': 'info',
-                'glow.context': { cartId: 7 },
-            },
-        });
-    });
-
-    test('defaults missing metaData to empty object', () => {
-        const events = glowsToEvents([
-            {
-                name: 'x',
-                messageLevel: 'warning',
-                metaData: undefined as unknown as Record<string, unknown>,
-                time: 2,
-                microtime: 2,
-            },
-        ]);
-
-        expect(events[0].attributes['glow.context']).toEqual({});
-    });
-
-    test('returns empty array for empty input', () => {
-        expect(glowsToEvents([])).toEqual([]);
-    });
-});

package/tests/helpers/FakeApi.ts

@@ -1,20 +0,0 @@
-import { Api } from '../../src/api';
-import { Report } from '../../src/types';
-
-export class FakeApi extends Api {
-    reports: Report[] = [];
-
-    lastReport?: Report;
-    lastUrl?: string;
-    lastKey?: string | null;
-    lastReportBrowserExtensionErrors?: boolean;
-
-    report(report: Report, url: string, key: string | null, reportBrowserExtensionErrors: boolean): Promise<void> {
-        this.reports.push(report);
-        this.lastUrl = url;
-        this.lastKey = key;
-        this.lastReportBrowserExtensionErrors = reportBrowserExtensionErrors;
-        this.lastReport = report;
-        return Promise.resolve();
-    }
-}

package/tests/helpers/index.ts

@@ -1 +0,0 @@
-export * from './FakeApi';