fix: remove old events.

feat: remove events from Client
feat: add reason when stopping to server
feat: add HandlerTypes to types.ts
chore: fix tests

Author: addievo

src/RPCClient.ts

@@ -16,10 +16,8 @@ import type {
   MapCallers,
 } from './types';
 import type { ErrorRPCRemote } from './errors';
-import { CreateDestroy, ready } from '@matrixai/async-init/dist/CreateDestroy';
 import Logger from '@matrixai/logger';
 import { Timer } from '@matrixai/timer';
-import { createDestroy } from '@matrixai/async-init';
 import * as rpcUtilsMiddleware from './middleware';
 import * as rpcErrors from './errors';
 import * as rpcUtils from './utils';
@@ -30,24 +28,8 @@ import { toError } from './utils';
 
 const timerCleanupReasonSymbol = Symbol('timerCleanUpReasonSymbol');
 
-/**
- * Events:
- * - {@link events.Event}
- */
-interface RPCClient<M extends ClientManifest>
-  extends createDestroy.CreateDestroy {}
-/**
- * You must provide an error handler `addEventListener('error')`.
- * Otherwise, errors will just be ignored.
- *
- * Events:
- * - {@link events.EventRPCClientDestroy}
- * - {@link events.EventRPCClientDestroyed}
- */
-@createDestroy.CreateDestroy({
-  eventDestroy: events.EventRPCClientDestroy,
-  eventDestroyed: events.EventRPCClientDestroyed,
-})
+interface RPCClient<M extends ClientManifest> {}
+
 class RPCClient<M extends ClientManifest> {
   /**
    * @param obj
@@ -175,16 +157,9 @@ class RPCClient<M extends ClientManifest> {
   } = {}): Promise<void> {
     this.logger.info(`Destroying ${this.constructor.name}`);
 
-    // You can dispatch an event before the actual destruction starts
-    this.dispatchEvent(new events.EventRPCClientDestroy());
-
-    // Dispatch an event after the client has been destroyed
-    this.dispatchEvent(new events.EventRPCClientDestroyed());
-
     this.logger.info(`Destroyed ${this.constructor.name}`);
   }
 
-  @ready(new rpcErrors.ErrorRPCCallerFailed())
   public get methods(): MapCallers<M> {
     return this.methodsProxy as MapCallers<M>;
   }
@@ -198,7 +173,6 @@ class RPCClient<M extends ClientManifest> {
    * the provided I type.
    * @param ctx - ContextTimed used for timeouts and cancellation.
    */
-  @ready(new rpcErrors.ErrorMissingCaller())
   public async unaryCaller<I extends JSONValue, O extends JSONValue>(
     method: string,
     parameters: I,
@@ -235,7 +209,6 @@ class RPCClient<M extends ClientManifest> {
    * the provided I type.
    * @param ctx - ContextTimed used for timeouts and cancellation.
    */
-  @ready(new rpcErrors.ErrorRPCCallerFailed())
   public async serverStreamCaller<I extends JSONValue, O extends JSONValue>(
     method: string,
     parameters: I,
@@ -264,7 +237,6 @@ class RPCClient<M extends ClientManifest> {
    * @param method - Method name of the RPC call
    * @param ctx - ContextTimed used for timeouts and cancellation.
    */
-  @ready(new rpcErrors.ErrorRPCCallerFailed())
   public async clientStreamCaller<I extends JSONValue, O extends JSONValue>(
     method: string,
     ctx: Partial<ContextTimedInput> = {},
@@ -299,7 +271,6 @@ class RPCClient<M extends ClientManifest> {
    * @param method - Method name of the RPC call
    * @param ctx - ContextTimed used for timeouts and cancellation.
    */
-  @ready(new rpcErrors.ErrorRPCCallerFailed())
   public async duplexStreamCaller<I extends JSONValue, O extends JSONValue>(
     method: string,
     ctx: Partial<ContextTimedInput> = {},
@@ -439,7 +410,6 @@ class RPCClient<M extends ClientManifest> {
    * @param ctx - ContextTimed used for timeouts and cancellation.
    * @param id - Id is generated only once, and used throughout the stream for the rest of the communication
    */
-  @ready(new rpcErrors.ErrorRPCCallerFailed())
   public async rawStreamCaller(
     method: string,
     headerParams: JSONValue,

src/RPCServer.ts

@@ -18,7 +18,7 @@ import type { JSONValue } from './types';
 import type { IdGen } from './types';
 import type { ErrorRPC, ErrorRPCRemote } from './errors';
 import { ReadableStream, TransformStream } from 'stream/web';
-import { ready } from '@matrixai/async-init/dist/CreateDestroy';
+import { ready } from '@matrixai/async-init/dist/StartStop';
 import Logger from '@matrixai/logger';
 import { PromiseCancellable } from '@matrixai/async-cancellable';
 import { Timer } from '@matrixai/timer';
@@ -60,7 +60,7 @@ class RPCServer extends EventTarget {
    * @param obj.manifest - Server manifest used to define the rpc method
    * handlers.
    * @param obj.middlewareFactory - Middleware used to process the rpc messages.
-   * The middlewareFactory needs to be a function that starts a pair of
+   * The middlewareFactory needs to be a function that creates a pair of
    * transform streams that convert `Uint8Array` to `JSONRPCRequest` on the forward
    * path and `JSONRPCResponse` to `Uint8Array` on the reverse path.
    * @param obj.streamKeepAliveTimeoutTime - Time before a connection is cleaned up due to no activity. This is the
@@ -72,7 +72,7 @@ class RPCServer extends EventTarget {
    * the handler to handle timeout before it is forced to end. Defaults to 2,000 milliseconds.
    * @param obj.logger
    */
-  public static async startRPCServer({
+  public static async start({
     manifest,
     middlewareFactory = rpcUtilsMiddleware.defaultServerMiddlewareWrapper(),
     handlerTimeoutTime = Infinity, // 1 minute
@@ -209,10 +209,15 @@ class RPCServer extends EventTarget {
     this.filterSensitive = filterSensitive || rpcUtils.filterSensitive;
   }
 
-  public async stop(force: boolean = true): Promise<void> {
-    // Log and dispatch an event before starting the destruction
+  public async stop({
+    force = true,
+    reason = '',
+  }: {
+    force?: boolean;
+    reason?: string;
+  }): Promise<void> {
+    // Log an event before starting the destruction
     this.logger.info(`Stopping ${this.constructor.name}`);
-    this.dispatchEvent(new events.EventRPCServerStopping());
 
     // Your existing logic for stopping active streams and other cleanup
     if (force) {
@@ -225,8 +230,7 @@ class RPCServer extends EventTarget {
       await activeStream;
     }
 
-    // Log and dispatch an event after the destruction has been completed
-    this.dispatchEvent(new events.EventRPCServerStopped());
+    // Log  an event after the destruction has been completed
     this.logger.info(`Stopped ${this.constructor.name}`);
   }
 
@@ -449,7 +453,6 @@ class RPCServer extends EventTarget {
   /**
    * ID is associated with the stream, not individual messages.
    */
-  @ready(new rpcErrors.ErrorRPCHandlerFailed())
   public handleStream(rpcStream: RPCStream<Uint8Array, Uint8Array>) {
     // This will take a buffer stream of json messages and set up service
     //  handling for it.

src/events.ts

@@ -34,15 +34,10 @@ class EventRPCClientConnect extends EventRPCClient {}
 
 class EventRPCServerConnection extends EventRPCServer<RPCServer> {}
 
-class EventRPCServerCreate extends EventRPCServer {}
-
-class EventRPCServerCreated extends EventRPCServer {}
-
-class EventRPCServerDestroy extends EventRPCServer {}
-
-class EventRPCServerDestroyed extends EventRPCServer {}
 class EventRPCServerStart extends EventRPCServer {}
+
 class EventRPCServerStarted extends EventRPCServer {}
+
 class EventRPCServerStopping extends EventRPCServer {}
 
 class EventRPCServerStopped extends EventRPCServer {}
@@ -81,10 +76,6 @@ export {
   EventRPCClientError,
   EventRPCClientConnect,
   EventRPCServerConnection,
-  EventRPCServerCreate,
-  EventRPCServerCreated,
-  EventRPCServerDestroy,
-  EventRPCServerDestroyed,
   EventRPCServerError,
   EventRPCConnectionError,
   EventRPCServerStopping,

src/types.ts

@@ -332,12 +332,25 @@ type JSONValue =
   | undefined;
 
 type POJO = { [key: string]: any };
+
 type PromiseDeconstructed<T> = {
   p: Promise<T>;
   resolveP: (value: T | PromiseLike<T>) => void;
   rejectP: (reason?: any) => void;
 };
 
+type HandlerTypes<T> = T extends Handler<
+  infer Container,
+  infer Input,
+  infer Output
+>
+  ? {
+      container: Container;
+      input: Input;
+      output: Output;
+    }
+  : never;
+
 export type {
   IdGen,
   JSONRPCRequestMessage,
@@ -365,4 +378,5 @@ export type {
   JSONValue,
   POJO,
   PromiseDeconstructed,
+  HandlerTypes,
 };