@aspectly/core 0.1.0

package/src/BridgeInternal.test.ts

@@ -0,0 +1,403 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { BridgeInternal } from './BridgeInternal';
+import { BridgeEventType, BridgeResultType, BridgeErrorType } from './types';
+
+describe('BridgeInternal', () => {
+  let sendEvent: ReturnType<typeof vi.fn>;
+  let bridge: BridgeInternal;
+
+  beforeEach(() => {
+    sendEvent = vi.fn();
+    bridge = new BridgeInternal(sendEvent);
+  });
+
+  describe('init', () => {
+    it('should send Init event with methods', () => {
+      const handlers = {
+        greet: async () => ({ message: 'hello' }),
+        getData: async () => ({ data: 'value' }),
+      };
+
+      bridge.init(handlers);
+
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.Init,
+        data: {
+          methods: ['greet', 'getData'],
+        },
+      });
+    });
+
+    it('should resolve immediately if called with empty handlers', async () => {
+      const result = await bridge.init({});
+      expect(result).toBe(true);
+      expect(sendEvent).not.toHaveBeenCalled();
+    });
+
+    it('should return promise that resolves on InitResult', async () => {
+      const handlers = {
+        greet: async () => ({ message: 'hello' }),
+      };
+
+      const initPromise = bridge.init(handlers);
+
+      // Simulate receiving InitResult
+      bridge.handleCoreEvent({
+        type: BridgeEventType.InitResult,
+        data: true,
+      });
+
+      await expect(initPromise).resolves.toBe(true);
+    });
+  });
+
+  describe('handleCoreEvent', () => {
+    it('should handle Init event and send InitResult', () => {
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Init,
+        data: { methods: ['test'] },
+      });
+
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.InitResult,
+        data: true,
+      });
+      expect(bridge.isAvailable()).toBe(true);
+      expect(bridge.supports('test')).toBe(true);
+    });
+
+    it('should handle Request event and call handler', async () => {
+      const handler = vi.fn().mockResolvedValue({ success: true });
+
+      // First initialize the bridge by receiving Init from other side
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Init,
+        data: { methods: [] },
+      });
+
+      // Start init and simulate InitResult response
+      const initPromise = bridge.init({ greet: handler });
+      bridge.handleCoreEvent({
+        type: BridgeEventType.InitResult,
+        data: true,
+      });
+      await initPromise;
+      sendEvent.mockClear();
+
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Request,
+        data: {
+          method: 'greet',
+          params: { name: 'John' },
+          request_id: '1',
+        },
+      });
+
+      // Wait for async handler
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(handler).toHaveBeenCalledWith({ name: 'John' });
+    });
+
+    it('should send success result after handler completes', async () => {
+      const handler = vi.fn().mockResolvedValue({ message: 'Hello!' });
+
+      // Initialize bridge
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Init,
+        data: { methods: [] },
+      });
+
+      const initPromise = bridge.init({ greet: handler });
+      bridge.handleCoreEvent({
+        type: BridgeEventType.InitResult,
+        data: true,
+      });
+      await initPromise;
+      sendEvent.mockClear();
+
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Request,
+        data: {
+          method: 'greet',
+          params: {},
+          request_id: '1',
+        },
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.Result,
+        data: {
+          type: BridgeResultType.Success,
+          data: { message: 'Hello!' },
+          method: 'greet',
+          request_id: '1',
+        },
+      });
+    });
+
+    it('should send error result for unsupported methods', async () => {
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Request,
+        data: {
+          method: 'unknownMethod',
+          params: {},
+          request_id: '1',
+        },
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.Result,
+        data: {
+          type: BridgeResultType.Error,
+          request_id: '1',
+          method: 'unknownMethod',
+          data: {
+            error_message: expect.any(String),
+            error_type: BridgeErrorType.UNSUPPORTED_METHOD,
+          },
+        },
+      });
+    });
+
+    it('should send error result when handler throws', async () => {
+      const handler = vi.fn().mockRejectedValue(new Error('Handler error'));
+
+      // Initialize bridge
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Init,
+        data: { methods: [] },
+      });
+
+      const initPromise = bridge.init({ failing: handler });
+      bridge.handleCoreEvent({
+        type: BridgeEventType.InitResult,
+        data: true,
+      });
+      await initPromise;
+      sendEvent.mockClear();
+
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Request,
+        data: {
+          method: 'failing',
+          params: {},
+          request_id: '1',
+        },
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.Result,
+        data: {
+          type: BridgeResultType.Error,
+          request_id: '1',
+          method: 'failing',
+          data: {
+            error_message: 'Handler error',
+            error_type: BridgeErrorType.REJECTED,
+          },
+        },
+      });
+    });
+  });
+
+  describe('send', () => {
+    beforeEach(() => {
+      // Initialize bridge
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Init,
+        data: { methods: ['test'] },
+      });
+    });
+
+    it('should send request event', () => {
+      bridge.send('test', { foo: 'bar' });
+
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.Request,
+        data: {
+          method: 'test',
+          params: { foo: 'bar' },
+          request_id: expect.any(String),
+        },
+      });
+    });
+
+    it('should resolve promise on success result', async () => {
+      const promise = bridge.send<{ message: string }>('test', {});
+
+      // Simulate result
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Result,
+        data: {
+          type: BridgeResultType.Success,
+          data: { message: 'success' },
+          request_id: '0',
+          method: 'test',
+        },
+      });
+
+      await expect(promise).resolves.toEqual({ message: 'success' });
+    });
+
+    it('should reject promise on error result', async () => {
+      const promise = bridge.send('test', {});
+
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Result,
+        data: {
+          type: BridgeResultType.Error,
+          data: {
+            error_type: BridgeErrorType.REJECTED,
+            error_message: 'Failed',
+          },
+          request_id: '0',
+          method: 'test',
+        },
+      });
+
+      await expect(promise).rejects.toEqual({
+        error_type: BridgeErrorType.REJECTED,
+        error_message: 'Failed',
+      });
+    });
+
+    it('should reject with BRIDGE_NOT_AVAILABLE when not initialized', async () => {
+      const uninitializedBridge = new BridgeInternal(sendEvent);
+      const promise = uninitializedBridge.send('test', {});
+
+      await expect(promise).rejects.toEqual({
+        error_type: BridgeErrorType.BRIDGE_NOT_AVAILABLE,
+        error_message: 'Bridge is not available',
+      });
+    });
+  });
+
+  describe('subscribe/unsubscribe', () => {
+    it('should notify listeners on result events', () => {
+      const listener = vi.fn();
+      bridge.subscribe(listener);
+
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Result,
+        data: {
+          type: BridgeResultType.Success,
+          data: { foo: 'bar' },
+          method: 'test',
+        },
+      });
+
+      expect(listener).toHaveBeenCalledWith({
+        type: BridgeResultType.Success,
+        data: { foo: 'bar' },
+        method: 'test',
+      });
+    });
+
+    it('should stop notifying after unsubscribe', () => {
+      const listener = vi.fn();
+      bridge.subscribe(listener);
+      bridge.unsubscribe(listener);
+
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Result,
+        data: {
+          type: BridgeResultType.Success,
+          data: {},
+          method: 'test',
+        },
+      });
+
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('supports', () => {
+    it('should return false before initialization', () => {
+      expect(bridge.supports('test')).toBe(false);
+    });
+
+    it('should return true for supported methods after init', () => {
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Init,
+        data: { methods: ['greet', 'getData'] },
+      });
+
+      expect(bridge.supports('greet')).toBe(true);
+      expect(bridge.supports('getData')).toBe(true);
+      expect(bridge.supports('unknown')).toBe(false);
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should return false before initialization', () => {
+      expect(bridge.isAvailable()).toBe(false);
+    });
+
+    it('should return true after Init event', () => {
+      bridge.handleCoreEvent({
+        type: BridgeEventType.Init,
+        data: { methods: [] },
+      });
+
+      expect(bridge.isAvailable()).toBe(true);
+    });
+  });
+
+  describe('timeout', () => {
+    it('should use custom timeout from options', async () => {
+      vi.useFakeTimers();
+
+      const customBridge = new BridgeInternal(sendEvent, { timeout: 100 });
+
+      // Initialize bridge first
+      customBridge.handleCoreEvent({
+        type: BridgeEventType.Init,
+        data: { methods: [] },
+      });
+
+      const slowHandler = vi.fn().mockImplementation(
+        () => new Promise((resolve) => setTimeout(resolve, 200))
+      );
+      const initPromise = customBridge.init({ slow: slowHandler });
+      customBridge.handleCoreEvent({
+        type: BridgeEventType.InitResult,
+        data: true,
+      });
+      await initPromise;
+      sendEvent.mockClear();
+
+      customBridge.handleCoreEvent({
+        type: BridgeEventType.Request,
+        data: {
+          method: 'slow',
+          params: {},
+          request_id: '1',
+        },
+      });
+
+      await vi.advanceTimersByTimeAsync(150);
+
+      expect(sendEvent).toHaveBeenCalledWith({
+        type: BridgeEventType.Result,
+        data: {
+          type: BridgeResultType.Error,
+          request_id: '1',
+          method: 'slow',
+          data: {
+            error_message: 'Execution timeout exceeded',
+            error_type: BridgeErrorType.METHOD_EXECUTION_TIMEOUT,
+          },
+        },
+      });
+
+      vi.useRealTimers();
+    });
+  });
+});

package/src/BridgeInternal.ts

@@ -0,0 +1,305 @@
+import type {
+  BridgeData,
+  BridgeEvent,
+  BridgeHandlers,
+  BridgeInitEvent,
+  BridgeInitResultEvent,
+  BridgeListener,
+  BridgeOptions,
+  BridgeRequestEvent,
+  BridgeResultData,
+  BridgeResultError,
+  BridgeResultEvent,
+} from './types';
+import {
+  BridgeErrorType,
+  BridgeEventType,
+  BridgeResultType,
+} from './types';
+
+/**
+ * Creates a bridge event with the specified type and data
+ */
+export const internalEvent = (
+  type: BridgeEventType,
+  data: BridgeData
+): BridgeEvent => ({
+  type,
+  data,
+});
+
+/**
+ * Creates a result event
+ */
+export const internalResultEvent = (data: BridgeData): BridgeEvent =>
+  internalEvent(BridgeEventType.Result, data);
+
+interface InternalRequestPromise {
+  reject: (error: BridgeResultError) => void;
+  resolve: (result: BridgeResultData) => void;
+}
+
+interface InitPromise {
+  reject: () => void;
+  resolve: (success: boolean) => void;
+}
+
+type InternalEventSender = (event: BridgeEvent) => void;
+
+const DEFAULT_TIMEOUT = 100000;
+
+/**
+ * BridgeInternal handles the business logic of the bridge protocol.
+ * It manages request/response lifecycle, handler registration, and event routing.
+ */
+export class BridgeInternal {
+  private requests: InternalRequestPromise[] = [];
+  private handlers: BridgeHandlers = {};
+  private available = false;
+  private supportedMethods: string[] = [];
+  private listeners: BridgeListener[] = [];
+  private initPromise?: InitPromise;
+  private readonly sendEvent: InternalEventSender;
+  private readonly timeout: number;
+
+  constructor(sendEvent: InternalEventSender, options?: BridgeOptions) {
+    this.sendEvent = sendEvent;
+    this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+  }
+
+  /**
+   * Subscribe to all result events
+   */
+  public subscribe = (listener: BridgeListener): number => {
+    return this.listeners.push(listener);
+  };
+
+  /**
+   * Unsubscribe from result events
+   */
+  public unsubscribe = (listener: BridgeListener): void => {
+    this.listeners = this.listeners.filter(
+      (oldListener) => oldListener !== listener
+    );
+  };
+
+  private checkDiff = (a: string[], b: string[]): boolean => {
+    return (
+      a.filter((x) => !b.includes(x)).length > 0 ||
+      b.filter((x) => !a.includes(x)).length > 0
+    );
+  };
+
+  /**
+   * Initialize the bridge with handlers
+   * @param handlers Map of method names to handler functions
+   * @returns Promise that resolves when the other side acknowledges
+   */
+  public init = (handlers: BridgeHandlers = {}): Promise<boolean> => {
+    const oldMethods = Object.keys(this.handlers);
+    const newMethods = Object.keys(handlers);
+    this.handlers = handlers;
+    if (!this.checkDiff(oldMethods, newMethods)) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve, reject) => {
+      this.initPromise = { resolve, reject };
+      this.sendEvent(
+        internalEvent(BridgeEventType.Init, {
+          methods: newMethods,
+        })
+      );
+    });
+  };
+
+  /**
+   * Handle incoming bridge events
+   */
+  public handleCoreEvent = (event: BridgeEvent): void => {
+    const { type, data } = event;
+    switch (type) {
+      case BridgeEventType.Init:
+        this.handleInit(data as BridgeInitEvent);
+        break;
+      case BridgeEventType.InitResult:
+        this.handleInitResult(data as BridgeInitResultEvent);
+        break;
+      case BridgeEventType.Request:
+        this.handleRequest(data as BridgeRequestEvent);
+        break;
+      case BridgeEventType.Result:
+        this.handleResult(data as BridgeResultEvent);
+        break;
+    }
+  };
+
+  /**
+   * Handle incoming requests and execute the appropriate handler
+   */
+  public handleRequest = (request: BridgeRequestEvent): void => {
+    const { method, params, request_id } = request;
+    new Promise<BridgeResultData>((resolve, reject) => {
+      let timeout = false;
+      if (!Object.prototype.hasOwnProperty.call(this.handlers, method)) {
+        reject({
+          error_type: BridgeErrorType.UNSUPPORTED_METHOD,
+          error: new Error(`Handler for «${method}» is not registered`),
+        });
+        return;
+      }
+      const timer = setTimeout(() => {
+        timeout = true;
+        reject({
+          error_type: BridgeErrorType.METHOD_EXECUTION_TIMEOUT,
+          error: new Error('Execution timeout exceeded'),
+        });
+      }, this.timeout);
+      const handler = this.handlers[method];
+      if (!handler) {
+        reject({
+          error_type: BridgeErrorType.UNSUPPORTED_METHOD,
+          error: new Error(`Handler for «${method}» is undefined`),
+        });
+        return;
+      }
+      handler(params)
+        .then((result) => {
+          if (timeout) {
+            return;
+          }
+          clearTimeout(timer);
+          resolve(result as BridgeResultData);
+        })
+        .catch((error: Error) => {
+          if (timeout) {
+            return;
+          }
+          clearTimeout(timer);
+          reject({
+            error_type: BridgeErrorType.REJECTED,
+            error: error,
+          });
+        });
+    })
+      .then((data: BridgeResultData) => {
+        this.sendEvent(
+          internalResultEvent({
+            type: BridgeResultType.Success,
+            data,
+            method,
+            request_id,
+          })
+        );
+      })
+      .catch(
+        ({
+          error_type,
+          error,
+        }: {
+          error_type: BridgeErrorType;
+          error: Error;
+        }) => {
+          this.sendEvent(
+            internalResultEvent({
+              type: BridgeResultType.Error,
+              request_id,
+              method,
+              data: {
+                error_message: error.message,
+                error_type,
+              },
+            })
+          );
+        }
+      );
+  };
+
+  private handleResult = (result: BridgeResultEvent): void => {
+    this.handleRequestResult(result);
+    this.listeners.forEach((listener) => listener(result));
+  };
+
+  private handleRequestResult = (result: BridgeResultEvent): void => {
+    if (!result || !Object.prototype.hasOwnProperty.call(result, 'request_id')) {
+      return;
+    }
+    if (!Object.prototype.hasOwnProperty.call(result, 'type')) {
+      console.warn('unknown result', result);
+      return;
+    }
+    const { request_id, data, type } = result;
+    const request = this.requests[Number(request_id)];
+    if (!request) {
+      return;
+    }
+    if (type === BridgeResultType.Success) {
+      request.resolve(data);
+      return;
+    }
+    if (type === BridgeResultType.Error) {
+      request.reject(data as BridgeResultError);
+    }
+  };
+
+  private handleInit = (data: BridgeInitEvent): void => {
+    this.available = true;
+    this.supportedMethods = data.methods;
+    this.sendEvent(internalEvent(BridgeEventType.InitResult, true));
+  };
+
+  private handleInitResult = (success: BridgeInitResultEvent): void => {
+    if (success) {
+      this.initPromise?.resolve(true);
+    } else {
+      this.initPromise?.reject();
+    }
+  };
+
+  /**
+   * Send a request to the other side
+   * @param method Method name to invoke
+   * @param params Parameters to pass to the method
+   * @returns Promise that resolves with the result
+   */
+  public send = <TResult = unknown>(
+    method: string,
+    params: object
+  ): Promise<TResult> =>
+    new Promise((resolve, reject) => {
+      const request_id = (
+        this.requests.push({ resolve: resolve as (result: BridgeResultData) => void, reject }) - 1
+      ).toString();
+      if (!this.isAvailable()) {
+        this.handleCoreEvent(
+          internalResultEvent({
+            type: BridgeResultType.Error,
+            request_id,
+            method,
+            data: {
+              error_message: 'Bridge is not available',
+              error_type: BridgeErrorType.BRIDGE_NOT_AVAILABLE,
+            },
+          })
+        );
+        return;
+      }
+      this.sendEvent(
+        internalEvent(BridgeEventType.Request, {
+          method,
+          params,
+          request_id,
+        })
+      );
+    });
+
+  /**
+   * Check if a method is supported by the other side
+   */
+  public supports = (method: string): boolean =>
+    this.supportedMethods.includes(method);
+
+  /**
+   * Check if the bridge is available (initialized)
+   */
+  public isAvailable = (): boolean => this.available;
+}