apcore-js 0.5.0 → 0.7.0

package/tests/integration/test-error-propagation.test.ts

@@ -1,259 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { Executor } from '../../src/executor.js';
-import { FunctionModule } from '../../src/decorator.js';
-import { Registry } from '../../src/registry/registry.js';
-import { Middleware } from '../../src/middleware/base.js';
-import { Context, createIdentity } from '../../src/context.js';
-import { InMemoryExporter, TracingMiddleware } from '../../src/observability/tracing.js';
-import { MetricsCollector, MetricsMiddleware } from '../../src/observability/metrics.js';
-import {
-  ModuleNotFoundError,
-  SchemaValidationError,
-  ACLDeniedError,
-} from '../../src/errors.js';
-import { ACL } from '../../src/acl.js';
-
-describe('Error Propagation', () => {
-  it('ModuleNotFoundError for non-existent module', async () => {
-    const registry = new Registry();
-    const executor = new Executor({ registry });
-
-    await expect(executor.call('non.existent')).rejects.toThrow(ModuleNotFoundError);
-
-    try {
-      await executor.call('non.existent');
-    } catch (error) {
-      expect(error).toBeInstanceOf(ModuleNotFoundError);
-      expect((error as ModuleNotFoundError).details['moduleId']).toBe('non.existent');
-    }
-  });
-
-  it('SchemaValidationError on invalid input', async () => {
-    const registry = new Registry();
-    registry.register('validate.input', new FunctionModule({
-      execute: (inputs) => ({ result: 'ok' }),
-      moduleId: 'validate.input',
-      inputSchema: Type.Object({ name: Type.String() }),
-      outputSchema: Type.Object({ result: Type.String() }),
-      description: 'Input validation test',
-    }));
-
-    const executor = new Executor({ registry });
-
-    await expect(
-      executor.call('validate.input', { name: 123 }),
-    ).rejects.toThrow(SchemaValidationError);
-
-    try {
-      await executor.call('validate.input', { name: 123 });
-    } catch (error) {
-      expect(error).toBeInstanceOf(SchemaValidationError);
-      const details = (error as SchemaValidationError).details;
-      const errors = details['errors'] as Array<Record<string, unknown>>;
-      expect(errors.length).toBeGreaterThan(0);
-      expect(errors[0]).toHaveProperty('field');
-      expect(errors[0]).toHaveProperty('message');
-    }
-  });
-
-  it('SchemaValidationError on invalid output', async () => {
-    const registry = new Registry();
-    registry.register('validate.output', new FunctionModule({
-      execute: () => ({ count: 'not_a_number' }),
-      moduleId: 'validate.output',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({ count: Type.Number() }),
-      description: 'Output validation test',
-    }));
-
-    const executor = new Executor({ registry });
-
-    await expect(
-      executor.call('validate.output', {}),
-    ).rejects.toThrow(SchemaValidationError);
-  });
-
-  it('ACLDeniedError with tracing captures error span', async () => {
-    const registry = new Registry();
-    registry.register('protected', new FunctionModule({
-      execute: () => ({ data: 'secret' }),
-      moduleId: 'protected',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({ data: Type.String() }),
-      description: 'Protected module',
-    }));
-
-    const acl = new ACL([
-      { callers: ['@external'], targets: ['protected'], effect: 'deny', description: 'block externals' },
-    ], 'allow');
-
-    const exporter = new InMemoryExporter();
-    const executor = new Executor({
-      registry,
-      middlewares: [new TracingMiddleware(exporter)],
-      acl,
-    });
-
-    // ACL check happens BEFORE middleware before(), so tracing won't capture it
-    // The span is created in before() but ACL check is at step 4 (after middleware before)
-    // Actually looking at executor.call: step 4 is ACL, step 6 is middleware before
-    // Wait - step 6 is middleware before, but step 4 (ACL) happens before middleware
-    // So tracing middleware won't have a span for ACL errors
-    // Let's just verify the error is thrown
-    await expect(executor.call('protected')).rejects.toThrow(ACLDeniedError);
-  });
-
-  it('middleware onError recovery returns fallback output', async () => {
-    const registry = new Registry();
-    registry.register('failing', new FunctionModule({
-      execute: () => { throw new Error('Module failed'); },
-      moduleId: 'failing',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({ recovered: Type.Boolean() }),
-      description: 'Failing module',
-    }));
-
-    class RecoveryMiddleware extends Middleware {
-      override onError(
-        _moduleId: string,
-        _inputs: Record<string, unknown>,
-        _error: Error,
-        _context: Context,
-      ): Record<string, unknown> | null {
-        return { recovered: true };
-      }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new RecoveryMiddleware()] });
-    const result = await executor.call('failing', {});
-    expect(result).toEqual({ recovered: true });
-  });
-
-  it('middleware onError cascade: reverse order, first recovery wins', async () => {
-    const registry = new Registry();
-    registry.register('failing', new FunctionModule({
-      execute: () => { throw new Error('Module failed'); },
-      moduleId: 'failing',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      description: 'Failing module',
-    }));
-
-    const callOrder: string[] = [];
-
-    class MW1 extends Middleware {
-      override onError(
-        _moduleId: string,
-        _inputs: Record<string, unknown>,
-        _error: Error,
-        _context: Context,
-      ): Record<string, unknown> | null {
-        callOrder.push('mw1');
-        return { recoveredBy: 'mw1' };
-      }
-    }
-
-    class MW2 extends Middleware {
-      override onError(
-        _moduleId: string,
-        _inputs: Record<string, unknown>,
-        _error: Error,
-        _context: Context,
-      ): Record<string, unknown> | null {
-        callOrder.push('mw2');
-        return { recoveredBy: 'mw2' };
-      }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new MW1(), new MW2()] });
-    const result = await executor.call('failing', {});
-
-    // onError is called in reverse order: MW2 first, then MW1
-    // First non-null return wins (MW2)
-    expect(callOrder[0]).toBe('mw2');
-    expect(result).toEqual({ recoveredBy: 'mw2' });
-  });
-
-  it('MetricsMiddleware records error metrics', async () => {
-    const registry = new Registry();
-    registry.register('error.mod', new FunctionModule({
-      execute: () => { throw new Error('Test error'); },
-      moduleId: 'error.mod',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      description: 'Error module',
-    }));
-
-    const metrics = new MetricsCollector();
-    const executor = new Executor({ registry, middlewares: [new MetricsMiddleware(metrics)] });
-
-    await expect(executor.call('error.mod', {})).rejects.toThrow('Test error');
-
-    const snap = metrics.snapshot();
-    const counters = snap['counters'] as Record<string, number>;
-    expect(counters['apcore_module_calls_total|module_id=error.mod,status=error']).toBe(1);
-    expect(counters['apcore_module_errors_total|error_code=Error,module_id=error.mod']).toBe(1);
-  });
-
-  it('full observability stack captures error metrics and tracing', async () => {
-    const registry = new Registry();
-    registry.register('obs.error', new FunctionModule({
-      execute: () => { throw new Error('Observable error'); },
-      moduleId: 'obs.error',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      description: 'Observable error module',
-    }));
-
-    const metrics = new MetricsCollector();
-    const exporter = new InMemoryExporter();
-    const executor = new Executor({
-      registry,
-      middlewares: [new MetricsMiddleware(metrics), new TracingMiddleware(exporter)],
-    });
-
-    await expect(executor.call('obs.error', {})).rejects.toThrow('Observable error');
-
-    // Check metrics
-    const snap = metrics.snapshot();
-    const counters = snap['counters'] as Record<string, number>;
-    expect(counters['apcore_module_calls_total|module_id=obs.error,status=error']).toBe(1);
-
-    // Check tracing
-    const spans = exporter.getSpans();
-    expect(spans).toHaveLength(1);
-    expect(spans[0].status).toBe('error');
-    expect(spans[0].attributes['error_code']).toBe('Error');
-  });
-
-  it('SchemaValidationError includes field path, code, and message', async () => {
-    const registry = new Registry();
-    registry.register('multi.validate', new FunctionModule({
-      execute: (inputs) => ({ result: 'ok' }),
-      moduleId: 'multi.validate',
-      inputSchema: Type.Object({
-        name: Type.String(),
-        age: Type.Number(),
-      }),
-      outputSchema: Type.Object({ result: Type.String() }),
-      description: 'Multi-field validation',
-    }));
-
-    const executor = new Executor({ registry });
-
-    try {
-      await executor.call('multi.validate', { name: 123, age: 'not_a_number' });
-      expect.unreachable('should have thrown');
-    } catch (error) {
-      expect(error).toBeInstanceOf(SchemaValidationError);
-      const errors = (error as SchemaValidationError).details['errors'] as Array<Record<string, unknown>>;
-      expect(errors.length).toBeGreaterThanOrEqual(2);
-      for (const err of errors) {
-        expect(err).toHaveProperty('field');
-        expect(err).toHaveProperty('code');
-        expect(err).toHaveProperty('message');
-      }
-    }
-  });
-});

package/tests/integration/test-middleware-chain.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { Context } from '../../src/context.js';
-import { Executor } from '../../src/executor.js';
-import { FunctionModule } from '../../src/decorator.js';
-import { Registry } from '../../src/registry/registry.js';
-import { Middleware } from '../../src/middleware/base.js';
-import { BeforeMiddleware, AfterMiddleware } from '../../src/middleware/adapters.js';
-
-function createEchoModule(): FunctionModule {
-  return new FunctionModule({
-    execute: (inputs) => ({ value: inputs['x'] ?? 'default' }),
-    moduleId: 'echo',
-    inputSchema: Type.Object({ x: Type.Optional(Type.String()) }),
-    outputSchema: Type.Object({ value: Type.String() }),
-    description: 'Echo module',
-  });
-}
-
-describe('Middleware Chain', () => {
-  it('before middlewares run in order, after in reverse', async () => {
-    const registry = new Registry();
-    registry.register('echo', createEchoModule());
-
-    const order: string[] = [];
-
-    class MW1 extends Middleware {
-      override before() { order.push('before-1'); return null; }
-      override after() { order.push('after-1'); return null; }
-    }
-    class MW2 extends Middleware {
-      override before() { order.push('before-2'); return null; }
-      override after() { order.push('after-2'); return null; }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new MW1(), new MW2()] });
-    await executor.call('echo', { x: 'test' });
-
-    expect(order).toEqual(['before-1', 'before-2', 'after-2', 'after-1']);
-  });
-
-  it('before middleware can transform inputs', async () => {
-    const registry = new Registry();
-    registry.register('echo', createEchoModule());
-
-    class InputTransform extends Middleware {
-      override before(
-        _moduleId: string,
-        _inputs: Record<string, unknown>,
-        _context: Context,
-      ): Record<string, unknown> {
-        return { x: 'transformed' };
-      }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new InputTransform()] });
-    const result = await executor.call('echo', { x: 'original' });
-    expect(result['value']).toBe('transformed');
-  });
-
-  it('after middleware can transform output', async () => {
-    const registry = new Registry();
-    registry.register('echo', createEchoModule());
-
-    class Transform extends Middleware {
-      override after(
-        _moduleId: string,
-        _inputs: Record<string, unknown>,
-        output: Record<string, unknown>,
-      ): Record<string, unknown> {
-        return { value: `transformed-${output['value']}` };
-      }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new Transform()] });
-    const result = await executor.call('echo', { x: 'hello' });
-    expect(result['value']).toBe('transformed-hello');
-  });
-
-  it('adapter middlewares work', async () => {
-    const registry = new Registry();
-    registry.register('echo', createEchoModule());
-
-    const calls: string[] = [];
-    const beforeMw = new BeforeMiddleware((_moduleId, _inputs, _ctx) => {
-      calls.push('before-adapter');
-      return null;
-    });
-    const afterMw = new AfterMiddleware((_moduleId, _inputs, _output, _ctx) => {
-      calls.push('after-adapter');
-      return null;
-    });
-
-    const executor = new Executor({ registry, middlewares: [beforeMw, afterMw] });
-    await executor.call('echo', { x: 'test' });
-
-    expect(calls).toEqual(['before-adapter', 'after-adapter']);
-  });
-
-  it('use/remove middleware at runtime', async () => {
-    const registry = new Registry();
-    registry.register('echo', createEchoModule());
-
-    const calls: string[] = [];
-    class Tracker extends Middleware {
-      override before() { calls.push('tracked'); return null; }
-    }
-
-    const executor = new Executor({ registry });
-    const mw = new Tracker();
-    executor.use(mw);
-
-    await executor.call('echo', { x: 'a' });
-    expect(calls).toEqual(['tracked']);
-
-    executor.remove(mw);
-    await executor.call('echo', { x: 'b' });
-    expect(calls).toEqual(['tracked']); // Still just 1 call
-  });
-});