@flareapp/core 2.2.0 → 2.2.1

package/tests/hooks.test.ts

@@ -1,123 +0,0 @@
-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('beforeEvaluate returning null cancels the report', async () => {
-    client.configure({ beforeEvaluate: () => null });
-    await client.report(new Error());
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('beforeEvaluate returning false cancels the report', async () => {
-    client.configure({ beforeEvaluate: () => false });
-    await client.report(new Error());
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('async beforeEvaluate returning null cancels the report', async () => {
-    client.configure({ beforeEvaluate: async () => null });
-    await client.report(new Error());
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('async beforeEvaluate returning false cancels the report', async () => {
-    client.configure({ beforeEvaluate: async (): Promise<false> => false });
-    await client.report(new Error());
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('beforeEvaluate can mutate the error', async () => {
-    client.configure({
-        beforeEvaluate: (error) => {
-            error.message = 'rewritten';
-            return error;
-        },
-    });
-    await client.report(new Error());
-    expect(fakeApi.lastReport?.message).toBe('rewritten');
-});
-
-test('async beforeEvaluate can mutate the error', async () => {
-    client.configure({
-        beforeEvaluate: async (error) => {
-            error.message = 'rewritten';
-            return error;
-        },
-    });
-    await client.report(new Error());
-    expect(fakeApi.lastReport?.message).toBe('rewritten');
-});
-
-test('beforeSubmit returning null cancels the report', async () => {
-    client.configure({ beforeSubmit: () => null });
-    await client.report(new Error());
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('beforeSubmit returning false cancels the report', async () => {
-    client.configure({ beforeSubmit: () => false });
-    await client.report(new Error());
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('async beforeSubmit returning null cancels the report', async () => {
-    client.configure({ beforeSubmit: async () => null });
-    await client.report(new Error());
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('async beforeSubmit returning false cancels the report', async () => {
-    client.configure({ beforeSubmit: async (): Promise<false> => false });
-    await client.report(new Error());
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('beforeSubmit can mutate the report (camelCase fields)', async () => {
-    client.configure({
-        beforeSubmit: (report) => {
-            report.message = 'rewritten';
-            return report;
-        },
-    });
-    await client.report(new Error());
-    expect(fakeApi.lastReport?.message).toBe('rewritten');
-});
-
-test('async beforeSubmit can mutate the report', async () => {
-    client.configure({
-        beforeSubmit: async (report) => {
-            report.message = 'rewritten';
-            return report;
-        },
-    });
-    await client.report(new Error());
-    expect(fakeApi.lastReport?.message).toBe('rewritten');
-});
-
-test('beforeEvaluate can replace the error with a new Error', async () => {
-    client.configure({
-        beforeEvaluate: () => new Error('replaced'),
-    });
-    await client.report(new Error('original'));
-    expect(fakeApi.lastReport?.message).toBe('replaced');
-});
-
-test('beforeSubmit can mutate attributes', async () => {
-    client.configure({
-        beforeSubmit: (report) => {
-            report.attributes['custom.tag'] = 'value';
-            return report;
-        },
-    });
-    await client.report(new Error());
-    expect(fakeApi.lastReport?.attributes['custom.tag']).toBe('value');
-});

package/tests/light.test.ts

@@ -1,25 +0,0 @@
-import { expect, test } from 'vitest';
-
-import { Flare } from '../src';
-
-test('light', () => {
-    const client = new Flare();
-    client.light('key');
-
-    expect(client.config.key).toBe('key');
-});
-
-test('light() does not clobber a previously configured debug=true', () => {
-    const client = new Flare();
-    client.configure({ debug: true });
-    client.light('key');
-
-    expect(client.config.debug).toBe(true);
-});
-
-test('light() can still explicitly opt into debug', () => {
-    const client = new Flare();
-    client.light('key', true);
-
-    expect(client.config.debug).toBe(true);
-});

package/tests/nullFileReader.test.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { NullFileReader } from '../src/stacktrace/NullFileReader';
-
-describe('NullFileReader', () => {
-    it('returns null for any URL', async () => {
-        const reader = new NullFileReader();
-        expect(await reader.read('https://example.com/foo.js')).toBeNull();
-        expect(await reader.read('/local/path.ts')).toBeNull();
-    });
-});

package/tests/publicExports.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { createStackTrace, getCodeSnippet, readLinesFromFile } from '../src';
-
-describe('public exports from @flareapp/core', () => {
-    it('exports createStackTrace as a function', () => {
-        expect(typeof createStackTrace).toBe('function');
-    });
-
-    it('exports getCodeSnippet as a function', () => {
-        expect(typeof getCodeSnippet).toBe('function');
-    });
-
-    it('exports readLinesFromFile as a function', () => {
-        expect(typeof readLinesFromFile).toBe('function');
-    });
-});

package/tests/redactUrl.test.ts

@@ -1,151 +0,0 @@
-import { DEFAULT_URL_DENYLIST, Flare, redactUrlQuery, resolveDenylist } from '@flareapp/core';
-// @vitest-environment jsdom
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-
-import type { Attributes, Config } from '../src/types';
-import { FakeApi } from './helpers/FakeApi';
-
-describe('redactUrlQuery', () => {
-    test('redacts denylisted query keys', () => {
-        const result = redactUrlQuery('/page?token=abc&q=visible', DEFAULT_URL_DENYLIST);
-        expect(result).toBe('/page?token=[redacted]&q=visible');
-    });
-
-    test('redacts session-style keys', () => {
-        const result = redactUrlQuery('/page?session_id=xyz&tab=open', DEFAULT_URL_DENYLIST);
-        expect(result).toBe('/page?session_id=[redacted]&tab=open');
-    });
-
-    test('preserves hash fragment after query', () => {
-        const result = redactUrlQuery('/page?token=abc#section', DEFAULT_URL_DENYLIST);
-        expect(result).toBe('/page?token=[redacted]#section');
-    });
-
-    test('handles hash-router URLs (query inside hash)', () => {
-        const url = 'http://localhost/#/users/77?token=secret&tab=open';
-        const result = redactUrlQuery(url, DEFAULT_URL_DENYLIST);
-        expect(result).toBe('http://localhost/#/users/77?token=[redacted]&tab=open');
-    });
-
-    test('returns input unchanged when no query string present', () => {
-        expect(redactUrlQuery('/page', DEFAULT_URL_DENYLIST)).toBe('/page');
-        expect(redactUrlQuery('', DEFAULT_URL_DENYLIST)).toBe('');
-    });
-
-    test('honours a custom denylist', () => {
-        const result = redactUrlQuery('/page?secretKey=xyz&token=visible', /^secretKey$/);
-        expect(result).toBe('/page?secretKey=[redacted]&token=visible');
-    });
-
-    test('redacts keys without values', () => {
-        expect(redactUrlQuery('/page?token', DEFAULT_URL_DENYLIST)).toBe('/page?token');
-    });
-});
-
-describe('resolveDenylist', () => {
-    test('returns default when no custom pattern given', () => {
-        expect(resolveDenylist()).toBe(DEFAULT_URL_DENYLIST);
-    });
-
-    test('merges custom pattern with default', () => {
-        const merged = resolveDenylist(/myParam/i);
-        expect(merged.test('password')).toBe(true);
-        expect(merged.test('myParam')).toBe(true);
-    });
-
-    test('replaces default when replaceDefault is true', () => {
-        const replaced = resolveDenylist(/myParam/i, true);
-        expect(replaced.test('password')).toBe(false);
-        expect(replaced.test('myParam')).toBe(true);
-    });
-
-    test('strips global/sticky flags to prevent stateful .test()', () => {
-        const resolved = resolveDenylist(/secret/gi, true);
-        expect(resolved.flags).not.toContain('g');
-        expect(resolved.flags).not.toContain('y');
-
-        const url = '/page?secret=1&secret=2';
-        const result = redactUrlQuery(url, resolved);
-        expect(result).toBe('/page?secret=[redacted]&secret=[redacted]');
-    });
-
-    test('strips global/sticky flags when merging with default', () => {
-        const resolved = resolveDenylist(/myParam/gy);
-        expect(resolved.flags).not.toContain('g');
-        expect(resolved.flags).not.toContain('y');
-    });
-});
-
-function browserCollector(config: Readonly<Config>): Attributes {
-    const attrs: Attributes = { 'flare.entry_point.type': 'web' };
-    if (typeof window !== 'undefined' && window?.location?.href) {
-        attrs['flare.entry_point.value'] = redactUrlQuery(window.location.href, config.urlDenylist);
-        attrs['url.full'] = redactUrlQuery(window.location.href, config.urlDenylist);
-        if (window.location.search) {
-            attrs['url.query'] = redactUrlQuery(window.location.search, config.urlDenylist).replace(/^\?/, '');
-        }
-    }
-    return attrs;
-}
-
-describe('Flare URL scrubbing', () => {
-    let flare: Flare;
-    let api: FakeApi;
-    let originalHref: string;
-
-    beforeEach(() => {
-        originalHref = window.location.href;
-        api = new FakeApi();
-        flare = new Flare(api, browserCollector);
-        flare.light('test-key', false);
-    });
-
-    afterEach(() => {
-        window.history.replaceState({}, '', originalHref);
-    });
-
-    test('scrubs flare.entry_point.value, url.full, and url.query with default denylist', async () => {
-        window.history.replaceState({}, '', '/page?token=secret&q=visible');
-
-        await flare.report(new Error('boom'));
-
-        const attributes = api.lastReport!.attributes;
-        expect(attributes['flare.entry_point.value']).toContain('token=[redacted]');
-        expect(attributes['flare.entry_point.value']).toContain('q=visible');
-        expect(attributes['url.full']).toContain('token=[redacted]');
-        expect(attributes['url.query']).toBe('token=[redacted]&q=visible');
-    });
-
-    test('merges custom urlDenylist with default', async () => {
-        window.history.replaceState({}, '', '/page?secretKey=xyz&token=abc&q=visible');
-        flare.configure({ urlDenylist: /^secretKey$/ });
-
-        await flare.report(new Error('boom'));
-
-        const attributes = api.lastReport!.attributes;
-        expect(attributes['url.full']).toContain('secretKey=[redacted]');
-        expect(attributes['url.full']).toContain('token=[redacted]');
-        expect(attributes['url.full']).toContain('q=visible');
-    });
-
-    test('replaces default urlDenylist when replaceDefaultUrlDenylist is true', async () => {
-        window.history.replaceState({}, '', '/page?secretKey=xyz&token=stillVisible');
-        flare.configure({ urlDenylist: /^secretKey$/, replaceDefaultUrlDenylist: true });
-
-        await flare.report(new Error('boom'));
-
-        const attributes = api.lastReport!.attributes;
-        expect(attributes['url.full']).toContain('secretKey=[redacted]');
-        expect(attributes['url.full']).toContain('token=stillVisible');
-    });
-
-    test('omits url.query when no query string', async () => {
-        window.history.replaceState({}, '', '/page');
-
-        await flare.report(new Error('boom'));
-
-        const attributes = api.lastReport!.attributes;
-        expect(attributes['url.full']).toBeDefined();
-        expect(attributes['url.query']).toBeUndefined();
-    });
-});

package/tests/report.test.ts

@@ -1,146 +0,0 @@
-// @vitest-environment jsdom
-import { beforeEach, expect, test, vi } 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('report() emits new-format payload with required attributes', async () => {
-    await client.report(new Error('boom'));
-
-    const r = fakeApi.lastReport!;
-    expect(r.message).toBe('boom');
-    expect(r.exceptionClass).toBe('Error');
-    expect(r.isLog).toBeUndefined();
-    expect(r.attributes['telemetry.sdk.language']).toBe('javascript');
-    expect(r.attributes['telemetry.sdk.name']).toBe('@flareapp/core');
-    expect(r.attributes['flare.language.name']).toBe('javascript');
-});
-
-test('report() emits flare.entry_point.type=web when browser collector is injected', async () => {
-    const browserClient = new Flare(fakeApi, () => ({ 'flare.entry_point.type': 'web' })).configure({
-        key: 'key',
-        debug: true,
-    });
-    await browserClient.report(new Error('boom'));
-    expect(fakeApi.lastReport!.attributes['flare.entry_point.type']).toBe('web');
-});
-
-test('report() seenAtUnixNano is roughly current time in nanoseconds', async () => {
-    const before = Date.now() * 1_000_000;
-    await client.report(new Error('x'));
-    const after = Date.now() * 1_000_000;
-
-    const seen = fakeApi.lastReport!.seenAtUnixNano;
-    // Allow ~1ms wiggle in either direction.
-    expect(seen).toBeGreaterThanOrEqual(before - 1_000_000);
-    expect(seen).toBeLessThanOrEqual(after + 1_000_000);
-});
-
-test('reportMessage() sets isLog true and exceptionClass=Log', async () => {
-    await client.reportMessage('Hello, Flare!');
-
-    expect(fakeApi.lastReport!.isLog).toBe(true);
-    expect(fakeApi.lastReport!.exceptionClass).toBe('Log');
-    expect(fakeApi.lastReport!.message).toBe('Hello, Flare!');
-    expect(fakeApi.lastReport!.level).toBeUndefined();
-});
-
-test('reportMessage() with explicit level emits level field', async () => {
-    await client.reportMessage('hi', 'warning');
-
-    expect(fakeApi.lastReport!.level).toBe('warning');
-});
-
-test('payload contains stacktrace with camelCase frames', async () => {
-    await client.report(new Error('x'));
-
-    const frame = fakeApi.lastReport!.stacktrace[0];
-    expect(frame).toHaveProperty('lineNumber');
-    expect(frame).toHaveProperty('file');
-    expect(frame).not.toHaveProperty('line_number');
-});
-
-test('does not report browser extension errors by default', async () => {
-    await client.test();
-    expect(fakeApi.lastReportBrowserExtensionErrors).toBe(false);
-});
-
-test('can be configured to report browser extension errors', async () => {
-    client.configure({ reportBrowserExtensionErrors: true });
-    await client.test();
-    expect(fakeApi.lastReportBrowserExtensionErrors).toBe(true);
-});
-
-test('auto-populates code from error.code when string', async () => {
-    const err = Object.assign(new Error('boom'), { code: 'ENOTFOUND' });
-    await client.report(err);
-
-    expect(fakeApi.lastReport!.code).toBe('ENOTFOUND');
-});
-
-test('omits code when error.code is missing', async () => {
-    await client.report(new Error('boom'));
-
-    expect(fakeApi.lastReport!.code).toBeUndefined();
-});
-
-test('addContext writes into attributes["context.custom"]', async () => {
-    client.addContext('userId', 7);
-
-    await client.report(new Error('x'));
-
-    expect(fakeApi.lastReport!.attributes['context.custom']).toEqual({ userId: 7 });
-});
-
-test('addContextGroup writes into attributes["context.<group>"]', async () => {
-    client.addContextGroup('tenant', { id: 9 });
-
-    await client.report(new Error('x'));
-
-    expect(fakeApi.lastReport!.attributes['context.tenant']).toEqual({ id: 9 });
-});
-
-test('per-call attributes win over collected attributes', async () => {
-    await client.report(new Error('x'), { 'telemetry.sdk.name': 'overridden' });
-
-    expect(fakeApi.lastReport!.attributes['telemetry.sdk.name']).toBe('overridden');
-});
-
-test('events is always an array — never undefined', async () => {
-    await client.report(new Error('x'));
-    expect(Array.isArray(fakeApi.lastReport!.events)).toBe(true);
-});
-
-test('seenAtUnixNano reflects report() entry time, not post-stacktrace time', async () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date('2026-04-28T12:00:00.000Z'));
-    const entryNs = Date.now() * 1_000_000;
-
-    client.configure({
-        beforeEvaluate: (e) => {
-            vi.advanceTimersByTime(5000);
-            return e;
-        },
-    });
-
-    await client.report(new Error('x'));
-
-    expect(fakeApi.lastReport!.seenAtUnixNano).toBe(entryNs);
-
-    vi.useRealTimers();
-});
-
-test('coerces non-Error inputs to a string message and Error class', async () => {
-    await client.report('plain string boom' as unknown as Error);
-
-    expect(fakeApi.lastReport!.message).toBe('plain string boom');
-    expect(fakeApi.lastReport!.exceptionClass).toBe('Error');
-});

package/tests/sampleRate.test.ts

@@ -1,88 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, beforeEach, expect, test, vi } 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 });
-});
-
-afterEach(() => {
-    vi.restoreAllMocks();
-});
-
-test('sampleRate defaults to 1 (all errors reported)', async () => {
-    expect(client.config.sampleRate).toBe(1);
-
-    await client.report(new Error('boom'));
-    expect(fakeApi.lastReport).toBeDefined();
-});
-
-test('sampleRate 0 drops all errors', async () => {
-    client.configure({ sampleRate: 0 });
-
-    for (let i = 0; i < 20; i++) {
-        await client.report(new Error(`error-${i}`));
-    }
-
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('sampleRate 0 drops all messages', async () => {
-    client.configure({ sampleRate: 0 });
-
-    for (let i = 0; i < 20; i++) {
-        await client.reportMessage(`msg-${i}`);
-    }
-
-    expect(fakeApi.reports).toHaveLength(0);
-});
-
-test('sampleRate 1 reports all errors', async () => {
-    client.configure({ sampleRate: 1 });
-
-    for (let i = 0; i < 10; i++) {
-        await client.report(new Error(`error-${i}`));
-    }
-
-    expect(fakeApi.reports).toHaveLength(10);
-});
-
-test('sampleRate controls proportion of reported errors', async () => {
-    client.configure({ sampleRate: 0.5 });
-
-    let callIndex = 0;
-    vi.spyOn(Math, 'random').mockImplementation(() => {
-        return callIndex++ % 2 === 0 ? 0.3 : 0.7;
-    });
-
-    for (let i = 0; i < 10; i++) {
-        await client.report(new Error(`error-${i}`));
-    }
-
-    expect(fakeApi.reports).toHaveLength(5);
-});
-
-test('test() always sends regardless of sampleRate', async () => {
-    client.configure({ sampleRate: 0 });
-
-    await client.test();
-
-    expect(fakeApi.lastReport).toBeDefined();
-    expect(fakeApi.lastReport!.message).toBe('The Flare client is set up correctly!');
-});
-
-test('sampleRate is clamped to 0 when negative', () => {
-    client.configure({ sampleRate: -0.5 });
-    expect(client.config.sampleRate).toBe(0);
-});
-
-test('sampleRate is clamped to 1 when above 1', () => {
-    client.configure({ sampleRate: 2 });
-    expect(client.config.sampleRate).toBe(1);
-});

package/tests/scope.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { GlobalScopeProvider, Scope } from '../src/Scope';
-import type { Glow } from '../src/types';
-
-const glow = (name: string): Glow => ({
-    name,
-    messageLevel: 'info',
-    metaData: {},
-    time: 0,
-    microtime: 0,
-});
-
-describe('Scope', () => {
-    it('starts empty', () => {
-        const scope = new Scope();
-        expect(scope.glows).toEqual([]);
-        expect(scope.pendingAttributes).toEqual({});
-        expect(scope.entryPoint).toBeNull();
-    });
-
-    it('adds glows and caps at max', () => {
-        const scope = new Scope();
-        scope.addGlow(glow('a'), 2);
-        scope.addGlow(glow('b'), 2);
-        scope.addGlow(glow('c'), 2);
-        expect(scope.glows.map((g) => g.name)).toEqual(['b', 'c']);
-    });
-
-    it('clears glows', () => {
-        const scope = new Scope();
-        scope.addGlow(glow('a'), 10);
-        scope.clearGlows();
-        expect(scope.glows).toEqual([]);
-    });
-
-    it('sets and merges attributes', () => {
-        const scope = new Scope();
-        scope.setAttribute('foo', 'bar');
-        scope.mergeAttributes({ baz: 1, foo: 'baz' });
-        expect(scope.pendingAttributes).toEqual({ foo: 'baz', baz: 1 });
-    });
-
-    it('stores entryPoint', () => {
-        const scope = new Scope();
-        scope.entryPoint = { identifier: '/foo', type: 'browser' };
-        expect(scope.entryPoint?.identifier).toBe('/foo');
-    });
-});
-
-describe('GlobalScopeProvider', () => {
-    it('returns the same scope on every active() call', () => {
-        const provider = new GlobalScopeProvider();
-        const a = provider.active();
-        const b = provider.active();
-        expect(a).toBe(b);
-    });
-
-    it('mutations on the active scope persist', () => {
-        const provider = new GlobalScopeProvider();
-        provider.active().setAttribute('k', 'v');
-        expect(provider.active().pendingAttributes).toEqual({ k: 'v' });
-    });
-});