feat: class based manifest

- Related #500
- Related #501

[ci skip]

src/RPC/RPCClient.ts

@@ -1,9 +1,9 @@
 import type {
   HandlerType,
   JsonRpcRequestMessage,
-  ServerManifest,
-  MapWithHandlers,
   StreamPairCreateCallback,
+  ClientManifest,
+  MapWithCallers,
 } from './types';
 import type { JSONValue } from 'types';
 import type {
@@ -15,18 +15,18 @@ import type {
   JsonRpcRequest,
   JsonRpcResponse,
   MiddlewareFactory,
-  MapHandlers,
+  MapCallers,
 } from './types';
 import { CreateDestroy, ready } from '@matrixai/async-init/dist/CreateDestroy';
 import Logger from '@matrixai/logger';
 import * as rpcErrors from './errors';
 import * as rpcUtils from './utils';
 
 // eslint-disable-next-line
-interface RPCClient<M extends ServerManifest> extends CreateDestroy {}
+interface RPCClient<M extends ClientManifest> extends CreateDestroy {}
 @CreateDestroy()
-class RPCClient<M extends ServerManifest> {
-  static async createRPCClient<M extends ServerManifest>({
+class RPCClient<M extends ClientManifest> {
+  static async createRPCClient<M extends ClientManifest>({
     manifest,
     streamPairCreateCallback,
     logger = new Logger(this.name),
@@ -113,13 +113,13 @@ class RPCClient<M extends ServerManifest> {
   }
 
   @ready(new rpcErrors.ErrorRpcDestroyed())
-  public get methods(): MapHandlers<M> {
-    return this.methodsProxy as MapHandlers<M>;
+  public get methods(): MapCallers<M> {
+    return this.methodsProxy as MapCallers<M>;
   }
 
   @ready(new rpcErrors.ErrorRpcDestroyed())
-  public get withMethods(): MapWithHandlers<M> {
-    return this.withMethodsProxy as MapWithHandlers<M>;
+  public get withMethods(): MapWithCallers<M> {
+    return this.withMethodsProxy as MapWithCallers<M>;
   }
 
   @ready(new rpcErrors.ErrorRpcDestroyed())

src/RPC/RPCServer.ts

@@ -12,7 +12,7 @@ import type {
   UnaryHandlerImplementation,
 } from './types';
 import type { ReadableWritablePair } from 'stream/web';
-import type { JSONValue, POJO } from '../types';
+import type { JSONValue } from '../types';
 import type { ConnectionInfo } from '../network/types';
 import type { RPCErrorEvent } from './utils';
 import type { MiddlewareFactory } from './types';

src/RPC/callers.ts

@@ -0,0 +1,53 @@
+import type { JSONValue } from 'types';
+import type { HandlerType } from './types';
+
+abstract class Caller<
+  Input extends JSONValue = JSONValue,
+  Output extends JSONValue = JSONValue,
+> {
+  protected _inputType: Input;
+  protected _outputType: Output;
+  // Need this to distinguish the classes when inferring types
+  abstract type: HandlerType;
+}
+
+class RawCaller extends Caller {
+  public type: 'RAW' = 'RAW' as const;
+}
+
+class DuplexCaller<
+  Input extends JSONValue = JSONValue,
+  Output extends JSONValue = JSONValue,
+> extends Caller<Input, Output> {
+  public type: 'DUPLEX' = 'DUPLEX' as const;
+}
+
+class ServerCaller<
+  Input extends JSONValue = JSONValue,
+  Output extends JSONValue = JSONValue,
+> extends Caller<Input, Output> {
+  public type: 'SERVER' = 'SERVER' as const;
+}
+
+class ClientCaller<
+  Input extends JSONValue = JSONValue,
+  Output extends JSONValue = JSONValue,
+> extends Caller<Input, Output> {
+  public type: 'CLIENT' = 'CLIENT' as const;
+}
+
+class UnaryCaller<
+  Input extends JSONValue = JSONValue,
+  Output extends JSONValue = JSONValue,
+> extends Caller<Input, Output> {
+  public type: 'UNARY' = 'UNARY' as const;
+}
+
+export {
+  Caller,
+  RawCaller,
+  DuplexCaller,
+  ServerCaller,
+  ClientCaller,
+  UnaryCaller,
+};

src/RPC/handlers.ts

@@ -13,8 +13,8 @@ abstract class Handler<
   Input extends JSONValue = JSONValue,
   Output extends JSONValue = JSONValue,
 > {
-  protected inputType: Input;
-  protected outputType: Output;
+  protected _inputType: Input;
+  protected _outputType: Output;
 
   constructor(protected container: Container) {}
 }

src/RPC/types.ts

@@ -7,6 +7,14 @@ import type {
   WritableStream,
 } from 'stream/web';
 import type { Handler } from './handlers';
+import type {
+  Caller,
+  RawCaller,
+  DuplexCaller,
+  ServerCaller,
+  ClientCaller,
+  UnaryCaller,
+} from './callers';
 
 /**
  * This is the JSON RPC request object. this is the generic message type used for the RPC.
@@ -142,136 +150,127 @@ type MiddlewareFactory<FR, FW, RR, RW> = (header?: JsonRpcRequest) => {
   reverse: ReadableWritablePair<RR, RW>;
 };
 
-type DuplexStreamCaller<
+type RawCallerImplementation = (
+  params: JSONValue,
+) => Promise<ReadableWritablePair<Uint8Array, Uint8Array>>;
+
+type DuplexCallerImplementation<
   I extends JSONValue = JSONValue,
   O extends JSONValue = JSONValue,
 > = () => Promise<ReadableWritablePair<O, I>>;
 
-type ServerStreamCaller<
+type ServerCallerImplementation<
   I extends JSONValue = JSONValue,
   O extends JSONValue = JSONValue,
 > = (parameters: I) => Promise<ReadableStream<O>>;
 
-type ClientStreamCaller<
+type ClientCallerImplementation<
   I extends JSONValue = JSONValue,
   O extends JSONValue = JSONValue,
 > = () => Promise<{
   output: Promise<O>;
   writable: WritableStream<I>;
 }>;
 
-type UnaryCaller<
+type UnaryCallerImplementation<
   I extends JSONValue = JSONValue,
   O extends JSONValue = JSONValue,
 > = (parameters: I) => Promise<O>;
 
-type RawStreamCaller = (
-  params: JSONValue,
-) => Promise<ReadableWritablePair<Uint8Array, Uint8Array>>;
-
-type ConvertDuplexStreamHandler<T> = T extends DuplexHandlerImplementation<
-  infer I,
-  infer O
->
-  ? DuplexStreamCaller<I, O>
+type ConvertDuplexCaller<T> = T extends DuplexCaller<infer I, infer O>
+  ? DuplexCallerImplementation<I, O>
   : never;
 
-type ConvertServerStreamHandler<T> = T extends ServerHandlerImplementation<
-  infer I,
-  infer O
->
-  ? ServerStreamCaller<I, O>
+type ConvertServerCaller<T> = T extends ServerCaller<infer I, infer O>
+  ? ServerCallerImplementation<I, O>
   : never;
 
-type ConvertClientStreamHandler<T> = T extends ClientHandlerImplementation<
-  infer I,
-  infer O
->
-  ? ClientStreamCaller<I, O>
+type ConvertClientCaller<T> = T extends ClientCaller<infer I, infer O>
+  ? ClientCallerImplementation<I, O>
   : never;
 
-type ConvertUnaryCaller<T> = T extends UnaryHandlerImplementation<
-  infer I,
-  infer O
->
-  ? UnaryCaller<I, O>
+type ConvertUnaryCaller<T> = T extends UnaryCaller<infer I, infer O>
+  ? UnaryCallerImplementation<I, O>
   : never;
 
-type ConvertHandler<T> = T extends DuplexHandlerImplementation
-  ? ConvertDuplexStreamHandler<T>
-  : T extends ServerHandlerImplementation
-  ? ConvertServerStreamHandler<T>
-  : T extends ClientHandlerImplementation
-  ? ConvertClientStreamHandler<T>
-  : T extends UnaryHandlerImplementation
+type ConvertCaller<T extends Caller> = T extends DuplexCaller
+  ? ConvertDuplexCaller<T>
+  : T extends ServerCaller
+  ? ConvertServerCaller<T>
+  : T extends ClientCaller
+  ? ConvertClientCaller<T>
+  : T extends UnaryCaller
   ? ConvertUnaryCaller<T>
-  : T extends RawHandlerImplementation
-  ? RawStreamCaller
+  : T extends RawCaller
+  ? RawCallerImplementation
   : never;
 
-type WithDuplexStreamCaller<
+type WithDuplexCallerImplementation<
   I extends JSONValue = JSONValue,
   O extends JSONValue = JSONValue,
 > = (f: (output: AsyncGenerator<O>) => AsyncGenerator<I>) => Promise<void>;
 
-type WithServerStreamCaller<
+type WithServerCallerImplementation<
   I extends JSONValue = JSONValue,
   O extends JSONValue = JSONValue,
 > = (
   parameters: I,
   f: (output: AsyncGenerator<O>) => Promise<void>,
 ) => Promise<void>;
 
-type WithClientStreamCaller<
+type WithClientCallerImplementation<
   I extends JSONValue = JSONValue,
   O extends JSONValue = JSONValue,
 > = (f: () => AsyncGenerator<I>) => Promise<O>;
 
-type WithRawStreamCaller = (
+type WithRawCallerImplementation = (
   params: JSONValue,
   f: (output: AsyncGenerator<Uint8Array>) => AsyncGenerator<Uint8Array>,
 ) => Promise<void>;
 
-type ConvertWithDuplexStreamHandler<T> = T extends DuplexHandlerImplementation<
+type ConvertWithDuplexStreamHandler<T> = T extends DuplexCaller<
   infer I,
   infer O
 >
-  ? WithDuplexStreamCaller<I, O>
+  ? WithDuplexCallerImplementation<I, O>
   : never;
 
-type ConvertWithServerStreamHandler<T> = T extends ServerHandlerImplementation<
+type ConvertWithServerStreamHandler<T> = T extends ServerCaller<
   infer I,
   infer O
 >
-  ? WithServerStreamCaller<I, O>
+  ? WithServerCallerImplementation<I, O>
   : never;
 
-type ConvertWithClientStreamHandler<T> = T extends ClientHandlerImplementation<
+type ConvertWithClientStreamHandler<T> = T extends ClientCaller<
   infer I,
   infer O
 >
-  ? WithClientStreamCaller<I, O>
+  ? WithClientCallerImplementation<I, O>
   : never;
 
-type ConvertWithHandler<T> = T extends DuplexHandlerImplementation
+type ConvertWithHandler<T> = T extends DuplexCaller
   ? ConvertWithDuplexStreamHandler<T>
-  : T extends ServerHandlerImplementation
+  : T extends ServerCaller
   ? ConvertWithServerStreamHandler<T>
-  : T extends ClientHandlerImplementation
+  : T extends ClientCaller
   ? ConvertWithClientStreamHandler<T>
-  : T extends RawHandlerImplementation
-  ? WithRawStreamCaller
+  : T extends RawCaller
+  ? WithRawCallerImplementation
   : never;
 
 type ServerManifest = Record<string, Handler>;
+type ClientManifest = Record<string, Caller>;
 
-// Type MapHandlers<T extends ServerManifest> = {
-//   [K in keyof T]: ConvertHandler<T[K]['handler']>;
-// };
+type HandlerType = 'DUPLEX' | 'SERVER' | 'CLIENT' | 'UNARY' | 'RAW';
 
-// type MapWithHandlers<T extends ServerManifest> = {
-//   [K in keyof T]: ConvertWithHandler<T[K]['handler']>;
-// };
+type MapCallers<T extends ClientManifest> = {
+  [K in keyof T]: ConvertCaller<T[K]>;
+};
+
+type MapWithCallers<T extends ClientManifest> = {
+  [K in keyof T]: ConvertWithHandler<T[K]>;
+};
 
 export type {
   JsonRpcRequestMessage,
@@ -292,6 +291,8 @@ export type {
   StreamPairCreateCallback,
   MiddlewareFactory,
   ServerManifest,
-  // MapHandlers,
-  // MapWithHandlers,
+  ClientManifest,
+  HandlerType,
+  MapCallers,
+  MapWithCallers,
 };

src/RPC/utils.ts

@@ -8,6 +8,8 @@ import type {
   JsonRpcRequest,
   JsonRpcResponse,
   MiddlewareFactory,
+  HandlerType,
+  ClientManifest,
 } from 'RPC/types';
 import type { JSONValue } from '../types';
 import { TransformStream } from 'stream/web';
@@ -562,13 +564,15 @@ function extractFirstMessageTransform<T extends JsonRpcMessage>(
   return { headTransformStream, firstMessageProm: messageProm.p };
 }
 
-// Function getHandlerTypes(manifest: ServerManifest): Record<string, HandlerType> {
-//   const out: Record<string, HandlerType> = {};
-//   for (const [k, v] of Object.entries(manifest)) {
-//     out[k] = v.type;
-//   }
-//   return out;
-// }
+function getHandlerTypes(
+  manifest: ClientManifest,
+): Record<string, HandlerType> {
+  const out: Record<string, HandlerType> = {};
+  for (const [k, v] of Object.entries(manifest)) {
+    out[k] = v.type;
+  }
+  return out;
+}
 
 const defaultMiddleware: MiddlewareFactory<
   JsonRpcRequest,
@@ -642,7 +646,7 @@ export {
   controllerTransformationFactory,
   queueMergingTransformStream,
   extractFirstMessageTransform,
-  // GetHandlerTypes,
+  getHandlerTypes,
   defaultMiddleware,
   defaultMiddlewareWrapper,
 };