apcore-js 0.5.0 → 0.7.0

package/tests/test-cancel.test.ts

@@ -1,71 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { CancelToken, ExecutionCancelledError } from '../src/cancel.js';
-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';
-
-describe('CancelToken', () => {
-  it('is initially not cancelled', () => {
-    const token = new CancelToken();
-    expect(token.isCancelled).toBe(false);
-  });
-
-  it('sets flag after cancel()', () => {
-    const token = new CancelToken();
-    token.cancel();
-    expect(token.isCancelled).toBe(true);
-  });
-
-  it('check() does nothing when not cancelled', () => {
-    const token = new CancelToken();
-    expect(() => token.check()).not.toThrow();
-  });
-
-  it('check() throws ExecutionCancelledError when cancelled', () => {
-    const token = new CancelToken();
-    token.cancel();
-    expect(() => token.check()).toThrow(ExecutionCancelledError);
-  });
-
-  it('reset() clears cancellation', () => {
-    const token = new CancelToken();
-    token.cancel();
-    expect(token.isCancelled).toBe(true);
-    token.reset();
-    expect(token.isCancelled).toBe(false);
-    expect(() => token.check()).not.toThrow();
-  });
-});
-
-describe('Executor cancellation', () => {
-  it('respects cancelled token before execution', async () => {
-    const registry = new Registry();
-    const mod = new FunctionModule({
-      execute: () => ({ result: 'ok' }),
-      moduleId: 'test.module',
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({ result: Type.String() }),
-      description: 'Simple module',
-    });
-    registry.register('test.module', mod);
-
-    const executor = new Executor({ registry });
-    const token = new CancelToken();
-    token.cancel();
-
-    const ctx = new Context(
-      'trace-1',
-      null,
-      [],
-      executor,
-      null,
-      null,
-      {},
-      token,
-    );
-
-    await expect(executor.call('test.module', {}, ctx)).rejects.toThrow(ExecutionCancelledError);
-  });
-});

package/tests/test-config.test.ts

@@ -1,76 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Config } from '../src/config.js';
-
-describe('Config', () => {
-  it('creates with provided data', () => {
-    const cfg = new Config({ name: 'test' });
-    expect(cfg.get('name')).toBe('test');
-  });
-
-  it('creates with no arguments', () => {
-    const cfg = new Config();
-    expect(cfg.get('anything')).toBeUndefined();
-  });
-
-  it('returns various value types', () => {
-    const cfg = new Config({
-      str: 'hello',
-      num: 42,
-      bool: true,
-      arr: [1, 2, 3],
-      obj: { nested: true },
-      nil: null,
-    });
-    expect(cfg.get('str')).toBe('hello');
-    expect(cfg.get('num')).toBe(42);
-    expect(cfg.get('bool')).toBe(true);
-    expect(cfg.get('arr')).toEqual([1, 2, 3]);
-    expect(cfg.get('obj')).toEqual({ nested: true });
-    expect(cfg.get('nil')).toBeNull();
-  });
-
-  it('traverses nested objects with dot-path', () => {
-    const cfg = new Config({
-      database: {
-        host: 'db.example.com',
-        port: 5432,
-        credentials: { user: 'admin', password: 'secret' },
-      },
-    });
-    expect(cfg.get('database.host')).toBe('db.example.com');
-    expect(cfg.get('database.port')).toBe(5432);
-    expect(cfg.get('database.credentials.user')).toBe('admin');
-  });
-
-  it('returns nested object for partial path', () => {
-    const cfg = new Config({ a: { b: { c: 'deep' } } });
-    expect(cfg.get('a.b')).toEqual({ c: 'deep' });
-  });
-
-  it('returns undefined when key missing and no default', () => {
-    const cfg = new Config({ x: 1 });
-    expect(cfg.get('y')).toBeUndefined();
-  });
-
-  it('returns default value when key missing', () => {
-    const cfg = new Config({ x: 1 });
-    expect(cfg.get('y', 'fallback')).toBe('fallback');
-    expect(cfg.get('y', 42)).toBe(42);
-  });
-
-  it('returns default when dot-path partially exists', () => {
-    const cfg = new Config({ a: { b: 1 } });
-    expect(cfg.get('a.c', 'default')).toBe('default');
-    expect(cfg.get('a.b.c.d', 'deep-default')).toBe('deep-default');
-  });
-
-  it('returns default when traversal hits non-object', () => {
-    const cfg = new Config({ a: 'string-value' });
-    expect(cfg.get('a.b', 'default')).toBe('default');
-  });
-
-  it('returns default when traversal hits null', () => {
-    const cfg = new Config({ a: null });
-    expect(cfg.get('a.b', 'default')).toBe('default');
-  });
-});

package/tests/test-context.test.ts

@@ -1,266 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Context, createIdentity } from '../src/context.js';
-import type { Identity } from '../src/context.js';
-
-describe('createIdentity', () => {
-  it('creates identity with defaults', () => {
-    const id = createIdentity('user1');
-    expect(id.id).toBe('user1');
-    expect(id.type).toBe('user');
-    expect(id.roles).toEqual([]);
-    expect(id.attrs).toEqual({});
-  });
-
-  it('creates identity with all fields', () => {
-    const id = createIdentity('admin1', 'admin', ['superuser'], { org: 'acme' });
-    expect(id.id).toBe('admin1');
-    expect(id.type).toBe('admin');
-    expect(id.roles).toEqual(['superuser']);
-    expect(id.attrs).toEqual({ org: 'acme' });
-  });
-
-  it('returns frozen object', () => {
-    const id = createIdentity('u1');
-    expect(Object.isFrozen(id)).toBe(true);
-    expect(Object.isFrozen(id.roles)).toBe(true);
-    expect(Object.isFrozen(id.attrs)).toBe(true);
-  });
-});
-
-describe('Context.create()', () => {
-  it('creates context with unique traceId', () => {
-    const ctx1 = Context.create();
-    const ctx2 = Context.create();
-    expect(ctx1.traceId).toBeDefined();
-    expect(ctx2.traceId).toBeDefined();
-    expect(ctx1.traceId).not.toBe(ctx2.traceId);
-  });
-
-  it('has null callerId by default', () => {
-    const ctx = Context.create();
-    expect(ctx.callerId).toBeNull();
-  });
-
-  it('has empty callChain by default', () => {
-    const ctx = Context.create();
-    expect(ctx.callChain).toEqual([]);
-  });
-
-  it('accepts executor and identity', () => {
-    const identity = createIdentity('u1', 'admin');
-    const executor = { name: 'test-executor' };
-    const ctx = Context.create(executor, identity);
-    expect(ctx.executor).toBe(executor);
-    expect(ctx.identity).toBe(identity);
-  });
-
-  it('defaults identity to null', () => {
-    const ctx = Context.create();
-    expect(ctx.identity).toBeNull();
-  });
-
-  it('defaults executor to null', () => {
-    const ctx = Context.create();
-    expect(ctx.executor).toBeNull();
-  });
-
-  it('defaults data to empty object', () => {
-    const ctx = Context.create();
-    expect(ctx.data).toEqual({});
-  });
-
-  it('accepts custom data', () => {
-    const ctx = Context.create(null, null, { key: 'value' });
-    expect(ctx.data).toEqual({ key: 'value' });
-  });
-
-  it('has null redactedInputs by default', () => {
-    const ctx = Context.create();
-    expect(ctx.redactedInputs).toBeNull();
-  });
-});
-
-describe('Context.child()', () => {
-  it('preserves traceId from parent', () => {
-    const parent = Context.create();
-    const child = parent.child('module.a');
-    expect(child.traceId).toBe(parent.traceId);
-  });
-
-  it('sets callerId to null when parent callChain is empty', () => {
-    const parent = Context.create();
-    const child = parent.child('module.a');
-    expect(child.callerId).toBeNull();
-  });
-
-  it('sets callerId to last element of parent callChain', () => {
-    const parent = Context.create();
-    const child1 = parent.child('module.a');
-    expect(child1.callChain).toEqual(['module.a']);
-
-    const child2 = child1.child('module.b');
-    expect(child2.callerId).toBe('module.a');
-    expect(child2.callChain).toEqual(['module.a', 'module.b']);
-  });
-
-  it('builds up callChain through multiple levels', () => {
-    const root = Context.create();
-    const c1 = root.child('a');
-    const c2 = c1.child('b');
-    const c3 = c2.child('c');
-    expect(c3.callChain).toEqual(['a', 'b', 'c']);
-    expect(c3.callerId).toBe('b');
-  });
-
-  it('shares data reference with parent', () => {
-    const parent = Context.create(null, null, { shared: true });
-    const child = parent.child('mod');
-    expect(child.data).toBe(parent.data);
-
-    child.data['newKey'] = 'newValue';
-    expect(parent.data['newKey']).toBe('newValue');
-  });
-
-  it('preserves executor from parent', () => {
-    const executor = { id: 'exec' };
-    const parent = Context.create(executor);
-    const child = parent.child('mod');
-    expect(child.executor).toBe(executor);
-  });
-
-  it('preserves identity from parent', () => {
-    const identity = createIdentity('u1', 'admin', ['role1']);
-    const parent = Context.create(null, identity);
-    const child = parent.child('mod');
-    expect(child.identity).toBe(identity);
-  });
-
-  it('resets redactedInputs to null', () => {
-    const parent = Context.create();
-    parent.redactedInputs = { field: '***' };
-    const child = parent.child('mod');
-    expect(child.redactedInputs).toBeNull();
-  });
-
-  it('does not modify parent callChain', () => {
-    const parent = Context.create();
-    const chainBefore = [...parent.callChain];
-    parent.child('mod.a');
-    expect(parent.callChain).toEqual(chainBefore);
-  });
-});
-
-describe('Context.toJSON() / Context.fromJSON()', () => {
-  it('round-trips context with identity', () => {
-    const identity = createIdentity('user-42', 'admin', ['superuser', 'editor'], { org: 'acme' });
-    const executor = { name: 'test-executor' };
-    const original = new Context(
-      'trace-abc',
-      'caller-1',
-      ['mod.a', 'mod.b'],
-      executor,
-      identity,
-      { password: '***' },
-      { transient: 'value' },
-    );
-
-    const serialized = original.toJSON();
-    const restored = Context.fromJSON(serialized);
-
-    expect(restored.traceId).toBe(original.traceId);
-    expect(restored.callerId).toBe(original.callerId);
-    expect(restored.callChain).toEqual(['mod.a', 'mod.b']);
-    expect(restored.identity).not.toBeNull();
-    expect(restored.identity!.id).toBe('user-42');
-    expect(restored.identity!.type).toBe('admin');
-    expect([...restored.identity!.roles]).toEqual(['superuser', 'editor']);
-    expect({ ...restored.identity!.attrs }).toEqual({ org: 'acme' });
-    expect(restored.redactedInputs).toEqual({ password: '***' });
-    expect(restored.data).toEqual({ transient: 'value' });
-  });
-
-  it('round-trips context without identity', () => {
-    const original = new Context('trace-xyz', null, [], null, null, null);
-    const serialized = original.toJSON();
-    const restored = Context.fromJSON(serialized);
-
-    expect(restored.traceId).toBe('trace-xyz');
-    expect(restored.callerId).toBeNull();
-    expect(restored.callChain).toEqual([]);
-    expect(restored.identity).toBeNull();
-    expect(restored.redactedInputs).toBeNull();
-  });
-
-  it('excludes executor from toJSON output but includes data', () => {
-    const ctx = new Context('trace-1', null, [], 'my-executor', null, null, { key: 'included' });
-    const serialized = ctx.toJSON();
-
-    expect(serialized).not.toHaveProperty('executor');
-    expect(serialized).toHaveProperty('data');
-    expect(serialized.data).toEqual({ key: 'included' });
-  });
-
-  it('re-injects executor via fromJSON', () => {
-    const ctx = new Context('trace-2', null, [], 'original-exec');
-    const serialized = ctx.toJSON();
-    const newExecutor = { name: 'new-executor' };
-    const restored = Context.fromJSON(serialized, newExecutor);
-
-    expect(restored.executor).toBe(newExecutor);
-  });
-
-  it('defaults executor to null when not provided to fromJSON', () => {
-    const serialized = { traceId: 't1', callerId: null, callChain: [], identity: null, redactedInputs: null };
-    const restored = Context.fromJSON(serialized);
-    expect(restored.executor).toBeNull();
-  });
-
-  it('toJSON returns copies, not references', () => {
-    const identity = createIdentity('u1', 'user', ['r1'], { k: 'v' });
-    const ctx = new Context('t1', null, ['a', 'b'], null, identity, { field: 'val' }, { shared: true });
-    const serialized = ctx.toJSON();
-
-    // Mutate serialized copies
-    (serialized.callChain as string[]).push('mutated');
-    (serialized.identity as Record<string, unknown>).id = 'mutated';
-    (serialized.redactedInputs as Record<string, unknown>).extra = true;
-    (serialized.data as Record<string, unknown>).extra = true;
-
-    // Originals unchanged
-    expect(ctx.callChain).toEqual(['a', 'b']);
-    expect(ctx.identity!.id).toBe('u1');
-    expect(ctx.redactedInputs).toEqual({ field: 'val' });
-    expect(ctx.data).toEqual({ shared: true });
-  });
-
-  it('toJSON excludes internal keys starting with _', () => {
-    const ctx = Context.create();
-    ctx.data['visible'] = 'yes';
-    ctx.data['_tracing_spans'] = [1, 2, 3];
-    ctx.data['_internal'] = 42;
-    const serialized = ctx.toJSON();
-    const data = serialized.data as Record<string, unknown>;
-    expect(data['visible']).toBe('yes');
-    expect(data['_tracing_spans']).toBeUndefined();
-    expect(data['_internal']).toBeUndefined();
-  });
-
-  it('fromJSON handles null roles and attrs gracefully', () => {
-    const json = {
-      traceId: 'test-id',
-      callerId: null,
-      callChain: [],
-      identity: {
-        id: 'user-1',
-        type: 'user',
-        roles: null,
-        attrs: null,
-      },
-      data: {},
-    };
-    const ctx = Context.fromJSON(json);
-    expect(ctx.identity).toBeDefined();
-    expect(ctx.identity!.roles).toEqual([]);
-    expect(ctx.identity!.attrs).toEqual({});
-  });
-});

package/tests/test-decorator.test.ts

@@ -1,173 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { FunctionModule, module, normalizeResult, makeAutoId } from '../src/decorator.js';
-import { Context, createIdentity } from '../src/context.js';
-import { Registry } from '../src/registry/registry.js';
-
-const inputSchema = Type.Object({ name: Type.String() });
-const outputSchema = Type.Object({ greeting: Type.String() });
-
-describe('FunctionModule', () => {
-  it('wraps an execute function', async () => {
-    const fm = new FunctionModule({
-      execute: (inputs) => ({ greeting: `Hello, ${inputs['name']}!` }),
-      moduleId: 'greet.hello',
-      inputSchema,
-      outputSchema,
-      description: 'Says hello',
-    });
-    const ctx = Context.create(null, createIdentity('test-user'));
-    const result = await fm.execute({ name: 'World' }, ctx);
-    expect(result).toEqual({ greeting: 'Hello, World!' });
-  });
-
-  it('exposes correct properties', () => {
-    const fm = new FunctionModule({
-      execute: () => ({}),
-      moduleId: 'test.props',
-      inputSchema,
-      outputSchema,
-      description: 'Test props',
-      documentation: 'Some docs',
-      tags: ['tag1', 'tag2'],
-      version: '2.0.0',
-    });
-    expect(fm.moduleId).toBe('test.props');
-    expect(fm.description).toBe('Test props');
-    expect(fm.documentation).toBe('Some docs');
-    expect(fm.tags).toEqual(['tag1', 'tag2']);
-    expect(fm.version).toBe('2.0.0');
-  });
-
-  it('uses sensible defaults', () => {
-    const fm = new FunctionModule({
-      execute: () => ({}),
-      moduleId: 'test.defaults',
-      inputSchema,
-      outputSchema,
-    });
-    expect(fm.description).toBe('Module test.defaults');
-    expect(fm.documentation).toBeNull();
-    expect(fm.tags).toBeNull();
-    expect(fm.version).toBe('1.0.0');
-    expect(fm.annotations).toBeNull();
-    expect(fm.metadata).toBeNull();
-    expect(fm.examples).toBeNull();
-  });
-
-  it('normalizes null return value', async () => {
-    const fm = new FunctionModule({
-      execute: () => null as unknown as Record<string, unknown>,
-      moduleId: 'test.normalize',
-      inputSchema,
-      outputSchema,
-    });
-    const ctx = Context.create(null, createIdentity('test-user'));
-    const result = await fm.execute({}, ctx);
-    expect(result).toEqual({});
-  });
-});
-
-describe('normalizeResult', () => {
-  it('null returns empty object', () => {
-    expect(normalizeResult(null)).toEqual({});
-  });
-
-  it('undefined returns empty object', () => {
-    expect(normalizeResult(undefined)).toEqual({});
-  });
-
-  it('plain object passes through', () => {
-    const obj = { a: 1, b: 'two' };
-    expect(normalizeResult(obj)).toBe(obj);
-  });
-
-  it('string is wrapped in { result }', () => {
-    expect(normalizeResult('hello')).toEqual({ result: 'hello' });
-  });
-
-  it('number is wrapped in { result }', () => {
-    expect(normalizeResult(42)).toEqual({ result: 42 });
-  });
-
-  it('boolean is wrapped in { result }', () => {
-    expect(normalizeResult(true)).toEqual({ result: true });
-  });
-
-  it('array is wrapped in { result }', () => {
-    expect(normalizeResult([1, 2, 3])).toEqual({ result: [1, 2, 3] });
-  });
-});
-
-describe('module() factory', () => {
-  it('creates FunctionModule with correct properties', () => {
-    const fm = module({
-      id: 'factory.test',
-      inputSchema,
-      outputSchema,
-      description: 'Factory module',
-      execute: () => ({ greeting: 'hi' }),
-    });
-    expect(fm).toBeInstanceOf(FunctionModule);
-    expect(fm.moduleId).toBe('factory.test');
-    expect(fm.description).toBe('Factory module');
-  });
-
-  it('generates auto ID when not provided', () => {
-    const fm = module({
-      inputSchema,
-      outputSchema,
-      execute: () => ({}),
-    });
-    expect(fm.moduleId).toBe('anonymous');
-  });
-
-  it('passes through optional fields', () => {
-    const fm = module({
-      id: 'opts.check',
-      inputSchema,
-      outputSchema,
-      description: 'desc',
-      documentation: 'docs here',
-      tags: ['t1'],
-      version: '3.0.0',
-      metadata: { key: 'val' },
-      execute: () => ({}),
-    });
-    expect(fm.documentation).toBe('docs here');
-    expect(fm.tags).toEqual(['t1']);
-    expect(fm.version).toBe('3.0.0');
-    expect(fm.metadata).toEqual({ key: 'val' });
-  });
-
-  it('auto-registers with registry', () => {
-    const registry = new Registry();
-    const fm = module({
-      id: 'auto.registered',
-      inputSchema,
-      outputSchema,
-      execute: () => ({ ok: true }),
-      registry,
-    });
-    expect(registry.has('auto.registered')).toBe(true);
-    expect(registry.get('auto.registered')).toBe(fm);
-  });
-});
-
-describe('makeAutoId', () => {
-  it('lowercases and replaces non-alphanumeric', () => {
-    expect(makeAutoId('Hello World')).toBe('hello_world');
-  });
-
-  it('preserves dots', () => {
-    expect(makeAutoId('my.module.name')).toBe('my.module.name');
-  });
-
-  it('prefixes digit-leading segments', () => {
-    expect(makeAutoId('2fast.4you')).toBe('_2fast._4you');
-  });
-
-  it('handles valid IDs unchanged', () => {
-    expect(makeAutoId('valid_id')).toBe('valid_id');
-  });
-});