apcore-js 0.5.0 → 0.7.0

package/tests/test-middleware.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Middleware } from '../src/middleware/base.js';
-import { BeforeMiddleware, AfterMiddleware } from '../src/middleware/adapters.js';
-import { Context, createIdentity } from '../src/context.js';
-
-function makeContext(): Context {
-  return Context.create(null, createIdentity('test-user'));
-}
-
-describe('Middleware base class', () => {
-  it('before() returns null by default', () => {
-    const mw = new Middleware();
-    const ctx = makeContext();
-    expect(mw.before('mod.a', { x: 1 }, ctx)).toBeNull();
-  });
-
-  it('after() returns null by default', () => {
-    const mw = new Middleware();
-    const ctx = makeContext();
-    expect(mw.after('mod.a', { x: 1 }, { y: 2 }, ctx)).toBeNull();
-  });
-
-  it('onError() returns null by default', () => {
-    const mw = new Middleware();
-    const ctx = makeContext();
-    expect(mw.onError('mod.a', { x: 1 }, new Error('boom'), ctx)).toBeNull();
-  });
-});
-
-describe('BeforeMiddleware', () => {
-  it('wraps a callback and delegates to before()', () => {
-    const mw = new BeforeMiddleware((moduleId, inputs) => {
-      return { ...inputs, injected: moduleId };
-    });
-    const ctx = makeContext();
-    const result = mw.before('mod.x', { a: 1 }, ctx);
-    expect(result).toEqual({ a: 1, injected: 'mod.x' });
-  });
-
-  it('after() still returns null', () => {
-    const mw = new BeforeMiddleware(() => ({ replaced: true }));
-    const ctx = makeContext();
-    expect(mw.after('mod.x', {}, {}, ctx)).toBeNull();
-  });
-
-  it('onError() still returns null', () => {
-    const mw = new BeforeMiddleware(() => ({ replaced: true }));
-    const ctx = makeContext();
-    expect(mw.onError('mod.x', {}, new Error('fail'), ctx)).toBeNull();
-  });
-
-  it('can return null from callback', () => {
-    const mw = new BeforeMiddleware(() => null);
-    const ctx = makeContext();
-    expect(mw.before('mod.x', { a: 1 }, ctx)).toBeNull();
-  });
-});
-
-describe('AfterMiddleware', () => {
-  it('wraps a callback and delegates to after()', () => {
-    const mw = new AfterMiddleware((moduleId, _inputs, output) => {
-      return { ...output, processedBy: moduleId };
-    });
-    const ctx = makeContext();
-    const result = mw.after('mod.y', { a: 1 }, { out: 42 }, ctx);
-    expect(result).toEqual({ out: 42, processedBy: 'mod.y' });
-  });
-
-  it('before() still returns null', () => {
-    const mw = new AfterMiddleware(() => ({ replaced: true }));
-    const ctx = makeContext();
-    expect(mw.before('mod.y', {}, ctx)).toBeNull();
-  });
-
-  it('onError() still returns null', () => {
-    const mw = new AfterMiddleware(() => ({ replaced: true }));
-    const ctx = makeContext();
-    expect(mw.onError('mod.y', {}, new Error('fail'), ctx)).toBeNull();
-  });
-
-  it('can return null from callback', () => {
-    const mw = new AfterMiddleware(() => null);
-    const ctx = makeContext();
-    expect(mw.after('mod.y', {}, { out: 1 }, ctx)).toBeNull();
-  });
-});

package/tests/test-trace-context.test.ts

@@ -1,251 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { TraceContext } from '../src/trace-context.js';
-import type { TraceParent } from '../src/trace-context.js';
-import { Context } from '../src/context.js';
-import type { Span } from '../src/observability/tracing.js';
-
-const TRACEPARENT_RE = /^[0-9a-f]{2}-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$/;
-
-describe('TraceContext.inject()', () => {
-  it('produces a valid traceparent format', () => {
-    const ctx = Context.create();
-    const headers = TraceContext.inject(ctx);
-    expect(headers).toHaveProperty('traceparent');
-    expect(headers.traceparent).toMatch(TRACEPARENT_RE);
-  });
-
-  it('uses context traceId (dashes stripped)', () => {
-    const ctx = Context.create();
-    const headers = TraceContext.inject(ctx);
-    const parts = headers.traceparent.split('-');
-    const expectedHex = ctx.traceId.replace(/-/g, '');
-    // parts[1] is the trace_id field (but split by '-' means we need to
-    // reconstruct from parts 1..4 since the 32-hex is split by the overall format)
-    // Actually the format is: 00-<32hex>-<16hex>-<2hex>
-    // Splitting by '-' gives: ["00", <32hex>, <16hex>, <2hex>]
-    expect(parts[1]).toBe(expectedHex);
-  });
-
-  it('starts with version 00', () => {
-    const ctx = Context.create();
-    const headers = TraceContext.inject(ctx);
-    expect(headers.traceparent.startsWith('00-')).toBe(true);
-  });
-
-  it('ends with trace flags 01', () => {
-    const ctx = Context.create();
-    const headers = TraceContext.inject(ctx);
-    expect(headers.traceparent.endsWith('-01')).toBe(true);
-  });
-
-  it('uses spanId from tracing stack when available', () => {
-    const ctx = Context.create();
-    const fakeSpan: Span = {
-      traceId: ctx.traceId,
-      name: 'test',
-      startTime: 0,
-      spanId: 'abcdef0123456789',
-      parentSpanId: null,
-      attributes: {},
-      endTime: null,
-      status: 'ok',
-      events: [],
-    };
-    ctx.data['_tracing_spans'] = [fakeSpan];
-
-    const headers = TraceContext.inject(ctx);
-    const parts = headers.traceparent.split('-');
-    expect(parts[2]).toBe('abcdef0123456789');
-  });
-
-  it('generates random parentId when no spans exist', () => {
-    const ctx = Context.create();
-    const headers = TraceContext.inject(ctx);
-    const parts = headers.traceparent.split('-');
-    const parentId = parts[2];
-    expect(parentId).toHaveLength(16);
-    expect(parentId).toMatch(/^[0-9a-f]{16}$/);
-  });
-});
-
-describe('TraceContext.extract()', () => {
-  it('parses a valid traceparent header', () => {
-    const headers = { traceparent: '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01' };
-    const result = TraceContext.extract(headers);
-    expect(result).not.toBeNull();
-    expect(result!.version).toBe('00');
-    expect(result!.traceId).toBe('4bf92f3577b34da6a3ce929d0e0e4736');
-    expect(result!.parentId).toBe('00f067aa0ba902b7');
-    expect(result!.traceFlags).toBe('01');
-  });
-
-  it('returns null for missing header', () => {
-    const result = TraceContext.extract({});
-    expect(result).toBeNull();
-  });
-
-  it('returns null for unrelated headers', () => {
-    const result = TraceContext.extract({ 'other-header': 'value' });
-    expect(result).toBeNull();
-  });
-
-  it('returns null for malformed traceparent', () => {
-    const result = TraceContext.extract({ traceparent: 'invalid-format' });
-    expect(result).toBeNull();
-  });
-
-  it('returns null for short trace_id', () => {
-    const result = TraceContext.extract({ traceparent: '00-abc-00f067aa0ba902b7-01' });
-    expect(result).toBeNull();
-  });
-
-  it('normalizes uppercase to lowercase', () => {
-    const headers = { traceparent: '00-4BF92F3577B34DA6A3CE929D0E0E4736-00F067AA0BA902B7-01' };
-    const result = TraceContext.extract(headers);
-    expect(result).not.toBeNull();
-    expect(result!.traceId).toBe('4bf92f3577b34da6a3ce929d0e0e4736');
-  });
-
-  it('parses unsampled trace flags', () => {
-    const headers = { traceparent: '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00' };
-    const result = TraceContext.extract(headers);
-    expect(result).not.toBeNull();
-    expect(result!.traceFlags).toBe('00');
-  });
-
-  it('returns null for all-zero trace_id', () => {
-    const result = TraceContext.extract({ traceparent: '00-00000000000000000000000000000000-00f067aa0ba902b7-01' });
-    expect(result).toBeNull();
-  });
-
-  it('returns null for all-zero parent_id', () => {
-    const result = TraceContext.extract({ traceparent: '00-4bf92f3577b34da6a3ce929d0e0e4736-0000000000000000-01' });
-    expect(result).toBeNull();
-  });
-
-  it('returns null for version ff', () => {
-    const result = TraceContext.extract({ traceparent: 'ff-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01' });
-    expect(result).toBeNull();
-  });
-
-  it('returns a frozen object', () => {
-    const headers = { traceparent: '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01' };
-    const result = TraceContext.extract(headers);
-    expect(result).not.toBeNull();
-    expect(Object.isFrozen(result)).toBe(true);
-  });
-});
-
-describe('TraceContext.fromTraceparent()', () => {
-  it('parses a valid traceparent string', () => {
-    const tp = TraceContext.fromTraceparent('00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01');
-    expect(tp.version).toBe('00');
-    expect(tp.traceId).toBe('4bf92f3577b34da6a3ce929d0e0e4736');
-    expect(tp.parentId).toBe('00f067aa0ba902b7');
-    expect(tp.traceFlags).toBe('01');
-  });
-
-  it('throws on invalid traceparent', () => {
-    expect(() => TraceContext.fromTraceparent('not-a-valid-traceparent'))
-      .toThrow('Malformed traceparent');
-  });
-
-  it('throws on empty string', () => {
-    expect(() => TraceContext.fromTraceparent(''))
-      .toThrow('Malformed traceparent');
-  });
-
-  it('throws on missing parts', () => {
-    expect(() => TraceContext.fromTraceparent('00-4bf92f3577b34da6a3ce929d0e0e4736'))
-      .toThrow('Malformed traceparent');
-  });
-
-  it('throws on all-zero trace_id', () => {
-    expect(() => TraceContext.fromTraceparent('00-00000000000000000000000000000000-00f067aa0ba902b7-01'))
-      .toThrow('all-zero trace_id or parent_id');
-  });
-
-  it('throws on all-zero parent_id', () => {
-    expect(() => TraceContext.fromTraceparent('00-4bf92f3577b34da6a3ce929d0e0e4736-0000000000000000-01'))
-      .toThrow('all-zero trace_id or parent_id');
-  });
-
-  it('throws on version ff', () => {
-    expect(() => TraceContext.fromTraceparent('ff-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01'))
-      .toThrow('version ff is not allowed');
-  });
-
-  it('returns a frozen object', () => {
-    const tp = TraceContext.fromTraceparent('00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01');
-    expect(Object.isFrozen(tp)).toBe(true);
-  });
-});
-
-describe('Round-trip: inject -> extract', () => {
-  it('preserves trace_id through inject then extract', () => {
-    const ctx = Context.create();
-    const headers = TraceContext.inject(ctx);
-    const parsed = TraceContext.extract(headers);
-
-    expect(parsed).not.toBeNull();
-    const expectedHex = ctx.traceId.replace(/-/g, '');
-    expect(parsed!.traceId).toBe(expectedHex);
-  });
-
-  it('preserves parent_id through inject then extract', () => {
-    const ctx = Context.create();
-    const headers = TraceContext.inject(ctx);
-    const parsed = TraceContext.extract(headers);
-
-    expect(parsed).not.toBeNull();
-    const parts = headers.traceparent.split('-');
-    expect(parsed!.parentId).toBe(parts[2]);
-  });
-});
-
-describe('Context.create() with traceParent', () => {
-  it('uses traceParent traceId converted to UUID format', () => {
-    const tp: TraceParent = {
-      version: '00',
-      traceId: '4bf92f3577b34da6a3ce929d0e0e4736',
-      parentId: '00f067aa0ba902b7',
-      traceFlags: '01',
-    };
-    const ctx = Context.create(null, null, undefined, tp);
-    expect(ctx.traceId).toBe('4bf92f35-77b3-4da6-a3ce-929d0e0e4736');
-  });
-
-  it('produces a valid UUID string from traceParent', () => {
-    const tp: TraceParent = {
-      version: '00',
-      traceId: '4bf92f3577b34da6a3ce929d0e0e4736',
-      parentId: '00f067aa0ba902b7',
-      traceFlags: '01',
-    };
-    const ctx = Context.create(null, null, undefined, tp);
-    // Should match UUID format: 8-4-4-4-12
-    expect(ctx.traceId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-  });
-
-  it('still works without traceParent', () => {
-    const ctx = Context.create();
-    expect(ctx.traceId).toBeDefined();
-    expect(ctx.traceId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-  });
-
-  it('generates unique traceIds without traceParent', () => {
-    const ctx1 = Context.create();
-    const ctx2 = Context.create();
-    expect(ctx1.traceId).not.toBe(ctx2.traceId);
-  });
-
-  it('full round-trip: context -> inject -> extract -> create', () => {
-    const original = Context.create();
-    const headers = TraceContext.inject(original);
-    const parsed = TraceContext.extract(headers);
-    expect(parsed).not.toBeNull();
-
-    const restored = Context.create(null, null, undefined, parsed);
-    expect(restored.traceId).toBe(original.traceId);
-  });
-});

package/tests/utils/test-pattern.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { matchPattern } from '../../src/utils/pattern.js';
-
-describe('matchPattern – exact and trivial patterns', () => {
-  it('returns true when pattern is the lone wildcard *', () => {
-    expect(matchPattern('*', 'anything')).toBe(true);
-    expect(matchPattern('*', '')).toBe(true);
-  });
-
-  it('returns true when pattern has no wildcard and equals moduleId', () => {
-    expect(matchPattern('module.a', 'module.a')).toBe(true);
-  });
-
-  it('returns false when pattern has no wildcard and does not equal moduleId', () => {
-    expect(matchPattern('module.a', 'module.b')).toBe(false);
-  });
-});
-
-describe('matchPattern – prefix wildcard (pattern starts with non-*)', () => {
-  it('returns false when moduleId does not start with the prefix segment', () => {
-    // Pattern split: ['core.', ''] – prefix check fails immediately
-    expect(matchPattern('core.*', 'other.module')).toBe(false);
-  });
-
-  it('returns true when moduleId starts with the prefix segment', () => {
-    expect(matchPattern('core.*', 'core.auth')).toBe(true);
-  });
-});
-
-describe('matchPattern – suffix wildcard (pattern does not end with *)', () => {
-  it('returns false when moduleId does not end with the last segment (lines 26-27)', () => {
-    // Pattern 'a*z': segments = ['a', 'z']. moduleId 'a.b.c' starts with 'a',
-    // then the endsWith check for 'z' fails.
-    expect(matchPattern('a*z', 'a.b.c')).toBe(false);
-  });
-
-  it('returns true when moduleId ends with the last segment (lines 25-27 pass)', () => {
-    // Pattern 'a*c': segments = ['a', 'c']. moduleId 'a.b.c' starts with 'a'
-    // and ends with 'c'.
-    expect(matchPattern('a*c', 'a.b.c')).toBe(true);
-  });
-});
-
-describe('matchPattern – multi-segment wildcard (lines 20-23)', () => {
-  it('returns true when all middle segments are found in order (lines 20-23 exercised)', () => {
-    // Pattern 'a*b*c': segments = ['a', 'b', 'c'].
-    // moduleId 'aXXbYYc': startsWith 'a', then indexOf('b') found, then endsWith 'c'.
-    expect(matchPattern('a*b*c', 'aXXbYYc')).toBe(true);
-  });
-
-  it('returns false when a middle segment is not found – idx === -1 (line 21)', () => {
-    // Pattern 'a*MISSING*c': the substring 'MISSING' is absent in 'aXXbYYc'.
-    expect(matchPattern('a*MISSING*c', 'aXXbYYc')).toBe(false);
-  });
-
-  it('returns false when the second middle segment is not found after the first', () => {
-    // Pattern 'a*b*z': 'b' is found in 'aXXbYYc', but 'z' is not found after it.
-    expect(matchPattern('a*b*z', 'aXXbYYc')).toBe(false);
-  });
-
-  it('advances pos correctly so segments must appear in sequence, not out of order', () => {
-    // 'b' appears before 'X' in the string, so 'X' cannot be found *after* 'b'.
-    // Pattern 'a*b*X': 'b' at index 3, then indexOf('X', 4) returns -1.
-    expect(matchPattern('a*b*X', 'aXXbYYc')).toBe(false);
-  });
-});
-
-describe('matchPattern – pattern starting with * (no prefix check)', () => {
-  it('returns true when moduleId ends with the suffix of a leading-* pattern', () => {
-    // Pattern '*suffix': segments = ['', 'suffix']. The startsWith block is skipped.
-    // Loop i=1: 'suffix' is found in 'prefix.suffix'. Pattern ends with 'suffix'
-    // so endsWith check also passes.
-    expect(matchPattern('*suffix', 'prefix.suffix')).toBe(true);
-  });
-
-  it('returns false when moduleId does not end with the suffix', () => {
-    expect(matchPattern('*suffix', 'prefix.other')).toBe(false);
-  });
-
-  it('returns true for *-only-surrounded pattern when middle is found anywhere', () => {
-    // Pattern '*mid*': segments = ['', 'mid', '']. startsWith skipped (starts with *).
-    // Loop i=1: 'mid' found. Loop i=2: empty segment, continue. Pattern ends with *,
-    // so endsWith block is skipped. Returns true.
-    expect(matchPattern('*mid*', 'before.mid.after')).toBe(true);
-  });
-});
-
-describe('matchPattern – consecutive wildcards (empty middle segments, line 19)', () => {
-  it('returns true for a**b when moduleId starts with a and ends with b (empty segment skipped)', () => {
-    // Pattern 'a**b': segments = ['a', '', 'b']. Prefix 'a' matches.
-    // Loop i=1: segment '' → continue (line 19). Loop i=2: 'b' is found.
-    // endsWith 'b' check passes.
-    expect(matchPattern('a**b', 'aXYb')).toBe(true);
-  });
-
-  it('returns false for a**b when moduleId does not start with a', () => {
-    expect(matchPattern('a**b', 'zXYb')).toBe(false);
-  });
-
-  it('returns false for a**b when moduleId does not end with b', () => {
-    expect(matchPattern('a**b', 'aXYz')).toBe(false);
-  });
-
-  it('handles three consecutive wildcards – all middle segments are empty and skipped', () => {
-    // Pattern 'x***y': segments = ['x', '', '', 'y'].
-    expect(matchPattern('x***y', 'xABCy')).toBe(true);
-    expect(matchPattern('x***y', 'xABCz')).toBe(false);
-  });
-});

package/tsconfig.build.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "tests", "**/*.test.ts"]
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "resolveJsonModule": true,
-    "isolatedModules": true
-  },
-  "include": ["src/**/*.ts", "tests/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}

package/vitest.config.ts

@@ -1,18 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    coverage: {
-      provider: 'v8',
-      include: ['src/**/*.ts'],
-      exclude: ['src/**/index.ts'],
-      thresholds: {
-        lines: 90,
-        functions: 90,
-        branches: 90,
-        statements: 90,
-      },
-    },
-  },
-});