apcore-js 0.4.0 → 0.6.0

package/tests/test-executor-stream.test.ts

@@ -1,208 +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 { ModuleNotFoundError } from '../src/errors.js';
-
-function createSimpleModule(id: string): FunctionModule {
-  return new FunctionModule({
-    execute: (inputs) => ({ greeting: `Hello, ${inputs['name'] ?? 'world'}!` }),
-    moduleId: id,
-    inputSchema: Type.Object({ name: Type.Optional(Type.String()) }),
-    outputSchema: Type.Object({ greeting: Type.String() }),
-    description: 'Greet module',
-  });
-}
-
-/**
- * Creates a module with a stream() async generator that yields chunks.
- */
-function createStreamingModule(id: string): FunctionModule & { stream: (inputs: Record<string, unknown>) => AsyncGenerator<Record<string, unknown>> } {
-  const mod = new FunctionModule({
-    execute: (inputs) => ({ greeting: `Hello, ${inputs['name'] ?? 'world'}!` }),
-    moduleId: id,
-    inputSchema: Type.Object({ name: Type.Optional(Type.String()) }),
-    outputSchema: Type.Object({ greeting: Type.String() }),
-    description: 'Streaming greet module',
-  });
-
-  // Attach a stream method to the module
-  const streamingMod = mod as FunctionModule & { stream: (inputs: Record<string, unknown>) => AsyncGenerator<Record<string, unknown>> };
-  streamingMod.stream = async function* (inputs: Record<string, unknown>): AsyncGenerator<Record<string, unknown>> {
-    const name = (inputs['name'] as string) ?? 'world';
-    yield { greeting: `Hello, ` };
-    yield { greeting: `${name}` };
-    yield { greeting: `!` };
-  };
-
-  return streamingMod;
-}
-
-async function collectChunks(gen: AsyncGenerator<Record<string, unknown>>): Promise<Record<string, unknown>[]> {
-  const chunks: Record<string, unknown>[] = [];
-  for await (const chunk of gen) {
-    chunks.push(chunk);
-  }
-  return chunks;
-}
-
-describe('Executor.stream()', () => {
-  it('falls back to single chunk when module has no stream()', async () => {
-    const registry = new Registry();
-    const mod = createSimpleModule('greet');
-    registry.register('greet', mod);
-
-    const executor = new Executor({ registry });
-    const chunks = await collectChunks(executor.stream('greet', { name: 'Alice' }));
-
-    expect(chunks).toHaveLength(1);
-    expect(chunks[0]['greeting']).toBe('Hello, Alice!');
-  });
-
-  it('yields multiple chunks from streaming module', async () => {
-    const registry = new Registry();
-    const mod = createStreamingModule('greet');
-    registry.register('greet', mod);
-
-    const executor = new Executor({ registry });
-    const chunks = await collectChunks(executor.stream('greet', { name: 'Bob' }));
-
-    expect(chunks.length).toBeGreaterThan(1);
-    expect(chunks[0]['greeting']).toBe('Hello, ');
-    expect(chunks[1]['greeting']).toBe('Bob');
-    expect(chunks[2]['greeting']).toBe('!');
-  });
-
-  it('throws ModuleNotFoundError for unknown module', async () => {
-    const registry = new Registry();
-    const executor = new Executor({ registry });
-
-    const chunks: Record<string, unknown>[] = [];
-    await expect(async () => {
-      for await (const chunk of executor.stream('nonexistent')) {
-        chunks.push(chunk);
-      }
-    }).rejects.toThrow(ModuleNotFoundError);
-  });
-
-  it('runs before-middleware before streaming and after-middleware on accumulated result', async () => {
-    const registry = new Registry();
-    const mod = createStreamingModule('echo');
-    registry.register('echo', mod);
-
-    const calls: string[] = [];
-    class TrackingMiddleware extends Middleware {
-      override before() { calls.push('before'); return null; }
-      override after() { calls.push('after'); return null; }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new TrackingMiddleware()] });
-    const chunks = await collectChunks(executor.stream('echo', { name: 'Test' }));
-
-    expect(chunks.length).toBeGreaterThan(0);
-    expect(calls).toContain('before');
-    expect(calls).toContain('after');
-    // before must come first
-    expect(calls.indexOf('before')).toBeLessThan(calls.indexOf('after'));
-  });
-
-  it('runs before-middleware before fallback and after-middleware on result', async () => {
-    const registry = new Registry();
-    const mod = createSimpleModule('echo');
-    registry.register('echo', mod);
-
-    const calls: string[] = [];
-    class TrackingMiddleware extends Middleware {
-      override before() { calls.push('before'); return null; }
-      override after() { calls.push('after'); return null; }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new TrackingMiddleware()] });
-    const chunks = await collectChunks(executor.stream('echo', { name: 'Test' }));
-
-    expect(chunks).toHaveLength(1);
-    expect(calls).toEqual(['before', 'after']);
-  });
-
-  it('handles middleware error recovery in streaming mode', async () => {
-    const registry = new Registry();
-    const failMod = new FunctionModule({
-      execute: () => { throw new Error('stream-boom'); },
-      moduleId: 'fail',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      description: 'Failing module',
-    });
-    registry.register('fail', failMod);
-
-    class RecoveryMiddleware extends Middleware {
-      override onError() { return { recovered: true }; }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new RecoveryMiddleware()] });
-    // Non-streaming module fallback with error should recover
-    const chunks = await collectChunks(executor.stream('fail'));
-    expect(chunks).toHaveLength(1);
-    expect(chunks[0]['recovered']).toBe(true);
-  });
-
-  it('accumulates chunks via shallow merge for after-middleware', async () => {
-    const registry = new Registry();
-    const mod = {
-      description: 'multi-key streaming module',
-      inputSchema: Type.Object({ prefix: Type.String() }),
-      outputSchema: Type.Object({ a: Type.Optional(Type.String()), b: Type.Optional(Type.String()) }),
-      execute: async (inputs: Record<string, unknown>) => ({ a: `${inputs['prefix']}_a`, b: `${inputs['prefix']}_b` }),
-      async *stream(inputs: Record<string, unknown>) {
-        yield { a: `${inputs['prefix']}_a` };
-        yield { b: `${inputs['prefix']}_b` };
-      },
-    };
-    registry.register('multi', mod);
-
-    let afterOutput: Record<string, unknown> | null = null;
-    const executor = new Executor({ registry });
-    executor.useAfter((_mid, _inputs, output) => {
-      afterOutput = { ...output };
-      return null;
-    });
-
-    const chunks: Record<string, unknown>[] = [];
-    for await (const chunk of executor.stream('multi', { prefix: 'test' })) {
-      chunks.push(chunk);
-    }
-
-    expect(chunks).toHaveLength(2);
-    expect(chunks[0]).toEqual({ a: 'test_a' });
-    expect(chunks[1]).toEqual({ b: 'test_b' });
-    // After-middleware should receive the MERGED result
-    expect(afterOutput).toEqual({ a: 'test_a', b: 'test_b' });
-  });
-
-  it('validates output schema on accumulated streaming result', async () => {
-    const registry = new Registry();
-    const mod = new FunctionModule({
-      execute: () => ({ greeting: 'fallback' }),
-      moduleId: 'validated',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({ greeting: Type.String() }),
-      description: 'Validated module',
-    });
-
-    // Attach a stream that produces valid accumulated output
-    const streamingMod = mod as FunctionModule & { stream: (inputs: Record<string, unknown>) => AsyncGenerator<Record<string, unknown>> };
-    streamingMod.stream = async function* (): AsyncGenerator<Record<string, unknown>> {
-      yield { greeting: 'chunk1' };
-      yield { greeting: 'chunk2' };
-    };
-
-    registry.register('validated', streamingMod);
-
-    const executor = new Executor({ registry });
-    // The last chunk is used as the accumulated output for validation
-    const chunks = await collectChunks(executor.stream('validated'));
-    expect(chunks).toHaveLength(2);
-  });
-});

package/tests/test-executor.test.ts

@@ -1,252 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { Context, createIdentity } from '../src/context.js';
-import { Executor, redactSensitive, REDACTED_VALUE } from '../src/executor.js';
-import { FunctionModule } from '../src/decorator.js';
-import { Registry } from '../src/registry/registry.js';
-import { ACL } from '../src/acl.js';
-import { Middleware } from '../src/middleware/base.js';
-import {
-  ModuleNotFoundError,
-  ACLDeniedError,
-  CallDepthExceededError,
-  CircularCallError,
-  CallFrequencyExceededError,
-  SchemaValidationError,
-} from '../src/errors.js';
-
-function createSimpleModule(id: string): FunctionModule {
-  return new FunctionModule({
-    execute: (inputs) => ({ greeting: `Hello, ${inputs['name'] ?? 'world'}!` }),
-    moduleId: id,
-    inputSchema: Type.Object({ name: Type.Optional(Type.String()) }),
-    outputSchema: Type.Object({ greeting: Type.String() }),
-    description: 'Greet module',
-  });
-}
-
-describe('redactSensitive', () => {
-  it('redacts fields marked x-sensitive', () => {
-    const data = { name: 'Alice', password: 'secret123' };
-    const schema = {
-      properties: {
-        name: { type: 'string' },
-        password: { type: 'string', 'x-sensitive': true },
-      },
-    };
-    const result = redactSensitive(data, schema);
-    expect(result['name']).toBe('Alice');
-    expect(result['password']).toBe(REDACTED_VALUE);
-  });
-
-  it('redacts _secret_ prefix keys', () => {
-    const data = { _secret_token: 'abc123', name: 'Bob' };
-    const schema = { properties: { name: { type: 'string' } } };
-    const result = redactSensitive(data, schema);
-    expect(result['_secret_token']).toBe(REDACTED_VALUE);
-    expect(result['name']).toBe('Bob');
-  });
-
-  it('does not modify original data', () => {
-    const data = { password: 'secret' };
-    const schema = { properties: { password: { type: 'string', 'x-sensitive': true } } };
-    redactSensitive(data, schema);
-    expect(data['password']).toBe('secret');
-  });
-
-  it('handles nested objects', () => {
-    const data = { user: { name: 'Alice', token: 'abc' } };
-    const schema = {
-      properties: {
-        user: {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            token: { type: 'string', 'x-sensitive': true },
-          },
-        },
-      },
-    };
-    const result = redactSensitive(data, schema);
-    expect((result['user'] as Record<string, unknown>)['name']).toBe('Alice');
-    expect((result['user'] as Record<string, unknown>)['token']).toBe(REDACTED_VALUE);
-  });
-});
-
-describe('Executor', () => {
-  it('executes a simple module', async () => {
-    const registry = new Registry();
-    const mod = createSimpleModule('greet');
-    registry.register('greet', mod);
-
-    const executor = new Executor({ registry });
-    const result = await executor.call('greet', { name: 'Alice' });
-    expect(result['greeting']).toBe('Hello, Alice!');
-  });
-
-  it('throws ModuleNotFoundError for unknown module', async () => {
-    const registry = new Registry();
-    const executor = new Executor({ registry });
-
-    await expect(executor.call('nonexistent')).rejects.toThrow(ModuleNotFoundError);
-  });
-
-  it('validates input against schema', async () => {
-    const registry = new Registry();
-    const mod = new FunctionModule({
-      execute: (inputs) => ({ result: inputs['count'] }),
-      moduleId: 'strict',
-      inputSchema: Type.Object({ count: Type.Number() }),
-      outputSchema: Type.Object({ result: Type.Number() }),
-      description: 'Strict module',
-    });
-    registry.register('strict', mod);
-
-    const executor = new Executor({ registry });
-    await expect(executor.call('strict', { count: 'not-a-number' })).rejects.toThrow(SchemaValidationError);
-  });
-
-  it('enforces ACL deny', async () => {
-    const registry = new Registry();
-    registry.register('secret', createSimpleModule('secret'));
-
-    const acl = new ACL([
-      { callers: ['@external'], targets: ['secret'], effect: 'deny', description: 'deny all' },
-    ], 'deny');
-
-    const executor = new Executor({ registry, acl });
-    await expect(executor.call('secret')).rejects.toThrow(ACLDeniedError);
-  });
-
-  it('enforces ACL allow', async () => {
-    const registry = new Registry();
-    registry.register('public', createSimpleModule('public'));
-
-    const acl = new ACL([
-      { callers: ['*'], targets: ['*'], effect: 'allow', description: 'allow all' },
-    ], 'deny');
-
-    const executor = new Executor({ registry, acl });
-    const result = await executor.call('public', { name: 'World' });
-    expect(result['greeting']).toBe('Hello, World!');
-  });
-
-  it('calls middleware before and after', async () => {
-    const registry = new Registry();
-    registry.register('echo', createSimpleModule('echo'));
-
-    const calls: string[] = [];
-    class TrackingMiddleware extends Middleware {
-      override before() { calls.push('before'); return null; }
-      override after() { calls.push('after'); return null; }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new TrackingMiddleware()] });
-    await executor.call('echo');
-    expect(calls).toEqual(['before', 'after']);
-  });
-
-  it('runs middleware onError on execution failure', async () => {
-    const registry = new Registry();
-    const failMod = new FunctionModule({
-      execute: () => { throw new Error('boom'); },
-      moduleId: 'fail',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      description: 'Failing module',
-    });
-    registry.register('fail', failMod);
-
-    let errorSeen = false;
-    class ErrorTracker extends Middleware {
-      override onError() { errorSeen = true; return null; }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new ErrorTracker()] });
-    await expect(executor.call('fail')).rejects.toThrow('boom');
-    expect(errorSeen).toBe(true);
-  });
-
-  it('middleware onError can recover', async () => {
-    const registry = new Registry();
-    const failMod = new FunctionModule({
-      execute: () => { throw new Error('boom'); },
-      moduleId: 'fail',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      description: 'Failing module',
-    });
-    registry.register('fail', failMod);
-
-    class RecoveryMiddleware extends Middleware {
-      override onError() { return { recovered: true }; }
-    }
-
-    const executor = new Executor({ registry, middlewares: [new RecoveryMiddleware()] });
-    const result = await executor.call('fail');
-    expect(result['recovered']).toBe(true);
-  });
-
-  it('validate() checks inputs without executing', () => {
-    const registry = new Registry();
-    const mod = new FunctionModule({
-      execute: () => ({ ok: true }),
-      moduleId: 'v',
-      inputSchema: Type.Object({ x: Type.Number() }),
-      outputSchema: Type.Object({ ok: Type.Boolean() }),
-      description: 'Validate test',
-    });
-    registry.register('v', mod);
-
-    const executor = new Executor({ registry });
-    const valid = executor.validate('v', { x: 42 });
-    expect(valid.valid).toBe(true);
-
-    const invalid = executor.validate('v', { x: 'not-a-number' });
-    expect(invalid.valid).toBe(false);
-    expect(invalid.errors.length).toBeGreaterThan(0);
-  });
-
-  it('auto-creates context when none provided', async () => {
-    const registry = new Registry();
-    registry.register('ctx', createSimpleModule('ctx'));
-
-    const executor = new Executor({ registry });
-    const result = await executor.call('ctx');
-    expect(result['greeting']).toBeDefined();
-  });
-
-  it('uses provided context', async () => {
-    const registry = new Registry();
-    let capturedCtx: Context | null = null;
-    const mod = new FunctionModule({
-      execute: (_inputs, ctx) => { capturedCtx = ctx; return { ok: true }; },
-      moduleId: 'ctx_test',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({ ok: Type.Boolean() }),
-      description: 'Context capture',
-    });
-    registry.register('ctx_test', mod);
-
-    const executor = new Executor({ registry });
-    const ctx = Context.create(executor, createIdentity('user1'));
-    await executor.call('ctx_test', {}, ctx);
-
-    expect(capturedCtx).not.toBeNull();
-    expect(capturedCtx!.traceId).toBe(ctx.traceId);
-    expect(capturedCtx!.identity?.id).toBe('user1');
-  });
-
-  it('use/remove middleware chaining', () => {
-    const registry = new Registry();
-    const executor = new Executor({ registry });
-    const mw = new Middleware();
-
-    const result = executor.use(mw);
-    expect(result).toBe(executor);
-    expect(executor.middlewares).toHaveLength(1);
-
-    executor.remove(mw);
-    expect(executor.middlewares).toHaveLength(0);
-  });
-});

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);
-    });
-  });
-});