apcore-js 0.5.0 → 0.6.0

package/tests/test-extensions.test.ts

@@ -1,310 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { ExtensionManager } from '../src/extensions.js';
-import type { ExtensionPoint } from '../src/extensions.js';
-import { Middleware } from '../src/middleware/index.js';
-import { ACL } from '../src/acl.js';
-import { Registry } from '../src/registry/registry.js';
-import { Executor } from '../src/executor.js';
-import { TracingMiddleware, InMemoryExporter } from '../src/observability/tracing.js';
-import type { Discoverer, ModuleValidator } from '../src/registry/registry.js';
-import type { SpanExporter, Span } from '../src/observability/tracing.js';
-
-// ---------------------------------------------------------------------------
-// Helpers: concrete implementations that satisfy the interfaces
-// ---------------------------------------------------------------------------
-
-class StubDiscoverer implements Discoverer {
-  discover(_roots: string[]) {
-    return [];
-  }
-}
-
-class StubValidator implements ModuleValidator {
-  validate(_module: unknown) {
-    return [];
-  }
-}
-
-class StubMiddleware extends Middleware {}
-
-class StubExporter implements SpanExporter {
-  export(_span: Span): void {
-    // no-op
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Tests: ExtensionManager basics
-// ---------------------------------------------------------------------------
-
-describe('ExtensionManager init', () => {
-  it('has five built-in extension points', () => {
-    const mgr = new ExtensionManager();
-    const points = mgr.listPoints();
-    expect(points).toHaveLength(5);
-  });
-
-  it('built-in point names match expected set', () => {
-    const mgr = new ExtensionManager();
-    const names = new Set(mgr.listPoints().map((p: ExtensionPoint) => p.name));
-    expect(names).toEqual(new Set(['discoverer', 'middleware', 'acl', 'span_exporter', 'module_validator']));
-  });
-
-  it('listPoints returns ExtensionPoint objects', () => {
-    const mgr = new ExtensionManager();
-    for (const p of mgr.listPoints()) {
-      expect(p).toHaveProperty('name');
-      expect(p).toHaveProperty('description');
-      expect(p).toHaveProperty('multiple');
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: register / get / getAll / unregister
-// ---------------------------------------------------------------------------
-
-describe('Discoverer extension', () => {
-  it('register and get', () => {
-    const mgr = new ExtensionManager();
-    const disc = new StubDiscoverer();
-    mgr.register('discoverer', disc);
-    expect(mgr.get('discoverer')).toBe(disc);
-  });
-
-  it('register replaces single', () => {
-    const mgr = new ExtensionManager();
-    const disc1 = new StubDiscoverer();
-    const disc2 = new StubDiscoverer();
-    mgr.register('discoverer', disc1);
-    mgr.register('discoverer', disc2);
-    expect(mgr.get('discoverer')).toBe(disc2);
-  });
-
-  it('unregister returns true', () => {
-    const mgr = new ExtensionManager();
-    const disc = new StubDiscoverer();
-    mgr.register('discoverer', disc);
-    expect(mgr.unregister('discoverer', disc)).toBe(true);
-    expect(mgr.get('discoverer')).toBeNull();
-  });
-
-  it('unregister returns false when missing', () => {
-    const mgr = new ExtensionManager();
-    const disc = new StubDiscoverer();
-    expect(mgr.unregister('discoverer', disc)).toBe(false);
-  });
-
-  it('get returns null when empty', () => {
-    const mgr = new ExtensionManager();
-    expect(mgr.get('discoverer')).toBeNull();
-  });
-});
-
-describe('Middleware extension', () => {
-  it('register and getAll', () => {
-    const mgr = new ExtensionManager();
-    const mw1 = new StubMiddleware();
-    const mw2 = new StubMiddleware();
-    mgr.register('middleware', mw1);
-    mgr.register('middleware', mw2);
-    expect(mgr.getAll('middleware')).toEqual([mw1, mw2]);
-  });
-
-  it('unregister specific', () => {
-    const mgr = new ExtensionManager();
-    const mw1 = new StubMiddleware();
-    const mw2 = new StubMiddleware();
-    mgr.register('middleware', mw1);
-    mgr.register('middleware', mw2);
-    mgr.unregister('middleware', mw1);
-    expect(mgr.getAll('middleware')).toEqual([mw2]);
-  });
-});
-
-describe('ACL extension', () => {
-  it('register and get', () => {
-    const mgr = new ExtensionManager();
-    const acl = new ACL([]);
-    mgr.register('acl', acl);
-    expect(mgr.get('acl')).toBe(acl);
-  });
-});
-
-describe('SpanExporter extension', () => {
-  it('register multiple', () => {
-    const mgr = new ExtensionManager();
-    const exp1 = new StubExporter();
-    const exp2 = new StubExporter();
-    mgr.register('span_exporter', exp1);
-    mgr.register('span_exporter', exp2);
-    expect(mgr.getAll('span_exporter')).toEqual([exp1, exp2]);
-  });
-});
-
-describe('ModuleValidator extension', () => {
-  it('register and get', () => {
-    const mgr = new ExtensionManager();
-    const val = new StubValidator();
-    mgr.register('module_validator', val);
-    expect(mgr.get('module_validator')).toBe(val);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: validation errors
-// ---------------------------------------------------------------------------
-
-describe('Validation', () => {
-  it('unknown point throws on register', () => {
-    const mgr = new ExtensionManager();
-    expect(() => mgr.register('nonexistent', {})).toThrow('Unknown extension point');
-  });
-
-  it('wrong type throws TypeError on register', () => {
-    const mgr = new ExtensionManager();
-    expect(() => mgr.register('middleware', 'not_a_middleware')).toThrow(TypeError);
-  });
-
-  it('get unknown point throws', () => {
-    const mgr = new ExtensionManager();
-    expect(() => mgr.get('nonexistent')).toThrow('Unknown extension point');
-  });
-
-  it('getAll unknown point throws', () => {
-    const mgr = new ExtensionManager();
-    expect(() => mgr.getAll('nonexistent')).toThrow('Unknown extension point');
-  });
-
-  it('unregister unknown point throws', () => {
-    const mgr = new ExtensionManager();
-    expect(() => mgr.unregister('nonexistent', {})).toThrow('Unknown extension point');
-  });
-
-  it('discoverer rejects wrong type', () => {
-    const mgr = new ExtensionManager();
-    expect(() => mgr.register('discoverer', new StubMiddleware())).toThrow(TypeError);
-  });
-
-  it('acl rejects wrong type', () => {
-    const mgr = new ExtensionManager();
-    expect(() => mgr.register('acl', new StubMiddleware())).toThrow(TypeError);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Tests: apply()
-// ---------------------------------------------------------------------------
-
-describe('apply()', () => {
-  it('wires discoverer into registry', () => {
-    const mgr = new ExtensionManager();
-    const disc = new StubDiscoverer();
-    mgr.register('discoverer', disc);
-
-    const registry = { setDiscoverer: vi.fn(), setValidator: vi.fn() } as unknown as Registry;
-    const executor = { use: vi.fn(), setAcl: vi.fn(), middlewares: [] } as unknown as Executor;
-    mgr.apply(registry, executor);
-
-    expect(registry.setDiscoverer).toHaveBeenCalledWith(disc);
-  });
-
-  it('wires validator into registry', () => {
-    const mgr = new ExtensionManager();
-    const val = new StubValidator();
-    mgr.register('module_validator', val);
-
-    const registry = { setDiscoverer: vi.fn(), setValidator: vi.fn() } as unknown as Registry;
-    const executor = { use: vi.fn(), setAcl: vi.fn(), middlewares: [] } as unknown as Executor;
-    mgr.apply(registry, executor);
-
-    expect(registry.setValidator).toHaveBeenCalledWith(val);
-  });
-
-  it('wires ACL into executor', () => {
-    const mgr = new ExtensionManager();
-    const acl = new ACL([]);
-    mgr.register('acl', acl);
-
-    const registry = { setDiscoverer: vi.fn(), setValidator: vi.fn() } as unknown as Registry;
-    const executor = { use: vi.fn(), setAcl: vi.fn(), middlewares: [] } as unknown as Executor;
-    mgr.apply(registry, executor);
-
-    expect(executor.setAcl).toHaveBeenCalledWith(acl);
-  });
-
-  it('wires middleware into executor', () => {
-    const mgr = new ExtensionManager();
-    const mw = new StubMiddleware();
-    mgr.register('middleware', mw);
-
-    const registry = { setDiscoverer: vi.fn(), setValidator: vi.fn() } as unknown as Registry;
-    const executor = { use: vi.fn(), setAcl: vi.fn(), middlewares: [] } as unknown as Executor;
-    mgr.apply(registry, executor);
-
-    expect(executor.use).toHaveBeenCalledWith(mw);
-  });
-
-  it('wires single span exporter into TracingMiddleware', () => {
-    const mgr = new ExtensionManager();
-    const newExp = new StubExporter();
-    mgr.register('span_exporter', newExp);
-
-    const inMem = new InMemoryExporter();
-    const tracingMw = new TracingMiddleware(inMem);
-
-    const registry = { setDiscoverer: vi.fn(), setValidator: vi.fn() } as unknown as Registry;
-    const executor = { use: vi.fn(), setAcl: vi.fn(), middlewares: [tracingMw] } as unknown as Executor;
-    mgr.apply(registry, executor);
-
-    // setExporter is used instead of direct private access
-    expect((tracingMw as unknown as Record<string, unknown>)['_exporter']).toBe(newExp);
-  });
-
-  it('wires multiple span exporters via composite exporter', () => {
-    const mgr = new ExtensionManager();
-    const exp1 = new StubExporter();
-    const exp2 = new StubExporter();
-    mgr.register('span_exporter', exp1);
-    mgr.register('span_exporter', exp2);
-
-    const inMem = new InMemoryExporter();
-    const tracingMw = new TracingMiddleware(inMem);
-
-    const registry = { setDiscoverer: vi.fn(), setValidator: vi.fn() } as unknown as Registry;
-    const executor = { use: vi.fn(), setAcl: vi.fn(), middlewares: [tracingMw] } as unknown as Executor;
-    mgr.apply(registry, executor);
-
-    // A composite exporter should have been set that delegates to both
-    const composite = (tracingMw as unknown as Record<string, unknown>)['_exporter'] as Record<string, unknown>;
-    expect(composite['_exporters']).toEqual([exp1, exp2]);
-  });
-
-  it('apply with no extensions is safe', () => {
-    const mgr = new ExtensionManager();
-    const registry = { setDiscoverer: vi.fn(), setValidator: vi.fn() } as unknown as Registry;
-    const executor = { use: vi.fn(), setAcl: vi.fn(), middlewares: [] } as unknown as Executor;
-    mgr.apply(registry, executor);
-
-    expect(registry.setDiscoverer).not.toHaveBeenCalled();
-    expect(registry.setValidator).not.toHaveBeenCalled();
-    expect(executor.use).not.toHaveBeenCalled();
-  });
-
-  it('warns when span_exporter registered but no TracingMiddleware present', () => {
-    const mgr = new ExtensionManager();
-    const newExp = new StubExporter();
-    mgr.register('span_exporter', newExp);
-
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-    const registry = { setDiscoverer: vi.fn(), setValidator: vi.fn() } as unknown as Registry;
-    const executor = { use: vi.fn(), setAcl: vi.fn(), middlewares: [] } as unknown as Executor;
-    mgr.apply(registry, executor);
-
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining('span_exporter'),
-    );
-    warnSpy.mockRestore();
-  });
-});

package/tests/test-logging-middleware.test.ts

@@ -1,150 +0,0 @@
-/**
- * Tests for middleware/logging.ts — LoggingMiddleware.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { LoggingMiddleware } from '../src/middleware/logging.js';
-import type { Logger } from '../src/middleware/logging.js';
-import { Context } from '../src/context.js';
-
-function makeContext(moduleId: string = 'test.mod'): Context {
-  const ctx = Context.create(null);
-  return ctx.child(moduleId);
-}
-
-function makeLogger(): Logger & { infoCalls: Array<[string, unknown]>; errorCalls: Array<[string, unknown]> } {
-  const logger = {
-    infoCalls: [] as Array<[string, unknown]>,
-    errorCalls: [] as Array<[string, unknown]>,
-    info(message: string, extra?: Record<string, unknown>) {
-      logger.infoCalls.push([message, extra]);
-    },
-    error(message: string, extra?: Record<string, unknown>) {
-      logger.errorCalls.push([message, extra]);
-    },
-  };
-  return logger;
-}
-
-describe('LoggingMiddleware', () => {
-  describe('before', () => {
-    it('logs module start with inputs when logInputs is true', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger, logInputs: true });
-      const ctx = makeContext('my.module');
-      const result = mw.before('my.module', { key: 'val' }, ctx);
-      expect(result).toBeNull();
-      expect(logger.infoCalls).toHaveLength(1);
-      expect(logger.infoCalls[0][0]).toContain('START my.module');
-    });
-
-    it('does not log when logInputs is false', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger, logInputs: false });
-      const ctx = makeContext();
-      mw.before('mod', { key: 'val' }, ctx);
-      expect(logger.infoCalls).toHaveLength(0);
-    });
-
-    it('stores start time in context data', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger });
-      const ctx = makeContext();
-      mw.before('mod', {}, ctx);
-      expect(typeof ctx.data['_logging_mw_start']).toBe('number');
-    });
-
-    it('uses redacted inputs when available', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger, logInputs: true });
-      const ctx = makeContext();
-      ctx.redactedInputs = { key: '***REDACTED***' };
-      mw.before('mod', { key: 'secret' }, ctx);
-      const extra = logger.infoCalls[0][1] as Record<string, unknown>;
-      expect(extra['inputs']).toEqual({ key: '***REDACTED***' });
-    });
-  });
-
-  describe('after', () => {
-    it('logs module end with duration when logOutputs is true', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger, logOutputs: true });
-      const ctx = makeContext('my.module');
-      ctx.data['_logging_mw_start'] = performance.now() - 100;
-      const result = mw.after('my.module', {}, { result: 'ok' }, ctx);
-      expect(result).toBeNull();
-      expect(logger.infoCalls).toHaveLength(1);
-      expect(logger.infoCalls[0][0]).toContain('END my.module');
-      expect(logger.infoCalls[0][0]).toMatch(/\d+\.\d+ms/);
-    });
-
-    it('does not log when logOutputs is false', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger, logOutputs: false });
-      const ctx = makeContext();
-      mw.after('mod', {}, { result: 'ok' }, ctx);
-      expect(logger.infoCalls).toHaveLength(0);
-    });
-
-    it('handles missing start time gracefully', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger, logOutputs: true });
-      const ctx = makeContext();
-      mw.after('mod', {}, { result: 'ok' }, ctx);
-      expect(logger.infoCalls).toHaveLength(1);
-    });
-  });
-
-  describe('onError', () => {
-    it('logs error with redacted inputs when logErrors is true', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger, logErrors: true });
-      const ctx = makeContext('my.module');
-      ctx.redactedInputs = { safe: 'data' };
-      const error = new Error('something broke');
-      const result = mw.onError('my.module', { secret: 'val' }, error, ctx);
-      expect(result).toBeNull();
-      expect(logger.errorCalls).toHaveLength(1);
-      expect(logger.errorCalls[0][0]).toContain('ERROR my.module');
-      const extra = logger.errorCalls[0][1] as Record<string, unknown>;
-      expect(extra['inputs']).toEqual({ safe: 'data' });
-    });
-
-    it('does not log when logErrors is false', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger, logErrors: false });
-      const ctx = makeContext();
-      mw.onError('mod', {}, new Error('fail'), ctx);
-      expect(logger.errorCalls).toHaveLength(0);
-    });
-
-    it('uses raw inputs when redactedInputs is null', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger, logErrors: true });
-      const ctx = makeContext();
-      mw.onError('mod', { raw: 'data' }, new Error('fail'), ctx);
-      const extra = logger.errorCalls[0][1] as Record<string, unknown>;
-      expect(extra['inputs']).toEqual({ raw: 'data' });
-    });
-  });
-
-  describe('defaults', () => {
-    it('uses default logger when none provided', () => {
-      const mw = new LoggingMiddleware();
-      const ctx = makeContext();
-      // Should not throw
-      expect(() => mw.before('mod', {}, ctx)).not.toThrow();
-    });
-
-    it('enables all logging by default', () => {
-      const logger = makeLogger();
-      const mw = new LoggingMiddleware({ logger });
-      const ctx = makeContext();
-      mw.before('mod', {}, ctx);
-      mw.after('mod', {}, { r: 1 }, ctx);
-      mw.onError('mod', {}, new Error('e'), ctx);
-      expect(logger.infoCalls).toHaveLength(2);
-      expect(logger.errorCalls).toHaveLength(1);
-    });
-  });
-});

package/tests/test-middleware-manager.test.ts

@@ -1,185 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Middleware } from '../src/middleware/base.js';
-import { MiddlewareManager, MiddlewareChainError } from '../src/middleware/manager.js';
-import { Context, createIdentity } from '../src/context.js';
-
-function makeContext(): Context {
-  return Context.create(null, createIdentity('test-user'));
-}
-
-class TaggingMiddleware extends Middleware {
-  readonly tag: string;
-
-  constructor(tag: string) {
-    super();
-    this.tag = tag;
-  }
-
-  override before(
-    _moduleId: string,
-    inputs: Record<string, unknown>,
-  ): Record<string, unknown> | null {
-    const trail = ((inputs['trail'] as string) ?? '') + this.tag;
-    return { ...inputs, trail };
-  }
-
-  override after(
-    _moduleId: string,
-    _inputs: Record<string, unknown>,
-    output: Record<string, unknown>,
-  ): Record<string, unknown> | null {
-    const trail = ((output['trail'] as string) ?? '') + this.tag;
-    return { ...output, trail };
-  }
-}
-
-class RecoveringMiddleware extends Middleware {
-  readonly recovery: Record<string, unknown>;
-
-  constructor(recovery: Record<string, unknown>) {
-    super();
-    this.recovery = recovery;
-  }
-
-  override onError(): Record<string, unknown> | null {
-    return this.recovery;
-  }
-}
-
-describe('MiddlewareManager', () => {
-  it('starts empty', () => {
-    const mgr = new MiddlewareManager();
-    expect(mgr.snapshot()).toEqual([]);
-  });
-
-  it('add and snapshot', () => {
-    const mgr = new MiddlewareManager();
-    const mw1 = new Middleware();
-    const mw2 = new Middleware();
-    mgr.add(mw1);
-    mgr.add(mw2);
-    expect(mgr.snapshot()).toHaveLength(2);
-  });
-
-  it('snapshot returns a copy', () => {
-    const mgr = new MiddlewareManager();
-    mgr.add(new Middleware());
-    const snap = mgr.snapshot();
-    snap.pop();
-    expect(mgr.snapshot()).toHaveLength(1);
-  });
-
-  it('remove by identity', () => {
-    const mgr = new MiddlewareManager();
-    const mw1 = new Middleware();
-    const mw2 = new Middleware();
-    mgr.add(mw1);
-    mgr.add(mw2);
-    expect(mgr.remove(mw1)).toBe(true);
-    expect(mgr.snapshot()).toEqual([mw2]);
-  });
-
-  it('remove returns false when not found', () => {
-    const mgr = new MiddlewareManager();
-    expect(mgr.remove(new Middleware())).toBe(false);
-  });
-
-  it('executeBefore runs in forward order', () => {
-    const mgr = new MiddlewareManager();
-    mgr.add(new TaggingMiddleware('A'));
-    mgr.add(new TaggingMiddleware('B'));
-    mgr.add(new TaggingMiddleware('C'));
-    const ctx = makeContext();
-    const [result, executed] = mgr.executeBefore('mod.test', { trail: '' }, ctx);
-    expect(result['trail']).toBe('ABC');
-    expect(executed).toHaveLength(3);
-  });
-
-  it('executeBefore passes original inputs when all return null', () => {
-    const mgr = new MiddlewareManager();
-    mgr.add(new Middleware());
-    mgr.add(new Middleware());
-    const ctx = makeContext();
-    const [result] = mgr.executeBefore('mod.test', { x: 42 }, ctx);
-    expect(result).toEqual({ x: 42 });
-  });
-
-  it('executeAfter runs in reverse order', () => {
-    const mgr = new MiddlewareManager();
-    mgr.add(new TaggingMiddleware('A'));
-    mgr.add(new TaggingMiddleware('B'));
-    mgr.add(new TaggingMiddleware('C'));
-    const ctx = makeContext();
-    const result = mgr.executeAfter('mod.test', {}, { trail: '' }, ctx);
-    expect(result['trail']).toBe('CBA');
-  });
-
-  it('executeAfter passes original output when all return null', () => {
-    const mgr = new MiddlewareManager();
-    mgr.add(new Middleware());
-    const ctx = makeContext();
-    const result = mgr.executeAfter('mod.test', {}, { y: 99 }, ctx);
-    expect(result).toEqual({ y: 99 });
-  });
-
-  it('executeOnError returns first non-null recovery (reverse order)', () => {
-    const mgr = new MiddlewareManager();
-    const mwA = new RecoveringMiddleware({ recovered: 'A' });
-    const mwB = new RecoveringMiddleware({ recovered: 'B' });
-    mgr.add(mwA);
-    mgr.add(mwB);
-    const ctx = makeContext();
-    const result = mgr.executeOnError('mod.test', {}, new Error('oops'), ctx, [mwA, mwB]);
-    expect(result).toEqual({ recovered: 'B' });
-  });
-
-  it('executeOnError returns null when no recovery', () => {
-    const mgr = new MiddlewareManager();
-    const mw = new Middleware();
-    mgr.add(mw);
-    const ctx = makeContext();
-    const result = mgr.executeOnError('mod.test', {}, new Error('oops'), ctx, [mw]);
-    expect(result).toBeNull();
-  });
-
-  it('executeOnError swallows errors in onError handlers', () => {
-    class ThrowingOnError extends Middleware {
-      override onError(): Record<string, unknown> | null {
-        throw new Error('onError also failed');
-      }
-    }
-    const mgr = new MiddlewareManager();
-    const mwRecover = new RecoveringMiddleware({ safe: true });
-    const mwThrow = new ThrowingOnError();
-    mgr.add(mwRecover);
-    mgr.add(mwThrow);
-    const ctx = makeContext();
-    const result = mgr.executeOnError('mod.test', {}, new Error('original'), ctx, [mwRecover, mwThrow]);
-    expect(result).toEqual({ safe: true });
-  });
-
-  it('MiddlewareChainError wraps before() failure', () => {
-    class FailingBefore extends Middleware {
-      override before(): Record<string, unknown> | null {
-        throw new Error('before exploded');
-      }
-    }
-    const mgr = new MiddlewareManager();
-    const ok = new TaggingMiddleware('A');
-    const fail = new FailingBefore();
-    mgr.add(ok);
-    mgr.add(fail);
-    const ctx = makeContext();
-
-    let caught: MiddlewareChainError | undefined;
-    try {
-      mgr.executeBefore('mod.test', { trail: '' }, ctx);
-    } catch (e) {
-      caught = e as MiddlewareChainError;
-    }
-
-    expect(caught).toBeInstanceOf(MiddlewareChainError);
-    expect(caught!.original.message).toBe('before exploded');
-    expect(caught!.executedMiddlewares).toHaveLength(2);
-  });
-});