@k13engineering/yajrpc 0.0.2 → 0.0.4

package/dist/lib/coerce.js

@@ -1,4 +1,12 @@
-/*import type { TJsonRpcError, TJsonRpcMessage, TJsonRpcNotification, TJsonRpcOptionalId, TJsonRpcParameters, TJsonRpcRequest, TJsonRpcResponse } from "./types.ts";*/
+/*import type {
+  TJsonRpcError,
+  TJsonRpcMessage,
+  TJsonRpcNotification,
+  TJsonRpcOptionalId,
+  TJsonRpcParameters,
+  TJsonRpcRequest,
+  TJsonRpcResponse
+} from "./types.ts";*/
 
 /*type TCoerceParamsResult = {
   error: Error;

package/dist/lib/definitions/combined.d.ts

@@ -0,0 +1,37 @@
+import type { TNotifyMethod, TRequestMethod } from "../types.js";
+import type { TRpcNotificationsDefinition } from "./notification.js";
+import type { TRpcRequestsDefinition } from "./requests.js";
+declare const createCombined: <TSideARequests extends TRpcRequestsDefinition<any>, TSideANotifications extends TRpcNotificationsDefinition<any>, TSideBRequests extends TRpcRequestsDefinition<any>, TSideBNotifications extends TRpcNotificationsDefinition<any>>({ sideADefinitions, sideBDefinitions }: {
+    sideADefinitions: {
+        requests: TSideARequests;
+        notifications: TSideANotifications;
+    };
+    sideBDefinitions: {
+        requests: TSideBRequests;
+        notifications: TSideBNotifications;
+    };
+}) => {
+    sideA: ({ incomingRequests, incomingNotifications, outgoingRequest, outgoingNotify }: {
+        incomingRequests: Parameters<TSideARequests["createServer"]>[0];
+        incomingNotifications: Parameters<TSideANotifications["createServer"]>[0];
+        outgoingRequest: TRequestMethod;
+        outgoingNotify: TNotifyMethod;
+    }) => {
+        outgoingRequests: ReturnType<TSideBRequests["createClient"]>;
+        outgoingNotifications: ReturnType<TSideBNotifications["createClient"]>;
+        handleIncomingRequest: any;
+        handleIncomingNotification: any;
+    };
+    sideB: ({ incomingRequests, incomingNotifications, outgoingRequest, outgoingNotify }: {
+        incomingRequests: Parameters<TSideBRequests["createServer"]>[0];
+        incomingNotifications: Parameters<TSideBNotifications["createServer"]>[0];
+        outgoingRequest: TRequestMethod;
+        outgoingNotify: TNotifyMethod;
+    }) => {
+        outgoingRequests: ReturnType<TSideARequests["createClient"]>;
+        outgoingNotifications: ReturnType<TSideANotifications["createClient"]>;
+        handleIncomingRequest: any;
+        handleIncomingNotification: any;
+    };
+};
+export { createCombined };

package/dist/lib/definitions/combined.js

@@ -0,0 +1,102 @@
+/*import type {
+  TNotifyMethod,
+  TRequestMethod
+} from "../types.ts";*/
+/*import type { TRpcNotificationsDefinition } from "./notification.ts";*/
+/*import type { TRpcRequestsDefinition } from "./requests.ts";*/
+
+const createCombined = /*<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  TSideARequests extends TRpcRequestsDefinition<any>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  TSideANotifications extends TRpcNotificationsDefinition<any>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  TSideBRequests extends TRpcRequestsDefinition<any>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  TSideBNotifications extends TRpcNotificationsDefinition<any>>*/({
+    sideADefinitions,
+    sideBDefinitions
+  }/*: {
+    sideADefinitions: {
+      requests: TSideARequests;
+      notifications: TSideANotifications;
+    },
+    sideBDefinitions: {
+      requests: TSideBRequests;
+      notifications: TSideBNotifications;
+    }
+  }*/) => {
+
+  const sideA = ({
+    incomingRequests,
+    incomingNotifications,
+
+    outgoingRequest,
+    outgoingNotify
+  }/*: {
+    incomingRequests: Parameters<TSideARequests["createServer"]>[0];
+    incomingNotifications: Parameters<TSideANotifications["createServer"]>[0];
+
+    outgoingRequest: TRequestMethod;
+    outgoingNotify: TNotifyMethod;
+  }*/) => {
+    const { handleRequest } = sideADefinitions.requests.createServer(incomingRequests);
+    const { handleNotification } = sideADefinitions.notifications.createServer(incomingNotifications);
+
+    const outgoingRequests = sideBDefinitions.requests.createClient({
+      request: outgoingRequest
+    });
+
+    const outgoingNotifications = sideBDefinitions.notifications.createClient({
+      notify: outgoingNotify
+    });
+
+    return {
+      outgoingRequests: outgoingRequests /*as ReturnType<TSideBRequests["createClient"]>*/,
+      outgoingNotifications: outgoingNotifications /*as ReturnType<TSideBNotifications["createClient"]>*/,
+
+      handleIncomingRequest: handleRequest,
+      handleIncomingNotification: handleNotification
+    };
+  };
+
+  const sideB = ({
+    incomingRequests,
+    incomingNotifications,
+
+    outgoingRequest,
+    outgoingNotify
+  }/*: {
+    incomingRequests: Parameters<TSideBRequests["createServer"]>[0];
+    incomingNotifications: Parameters<TSideBNotifications["createServer"]>[0];
+
+    outgoingRequest: TRequestMethod
+    outgoingNotify: TNotifyMethod;
+  }*/) => {
+    const { handleRequest } = sideBDefinitions.requests.createServer(incomingRequests);
+    const { handleNotification } = sideBDefinitions.notifications.createServer(incomingNotifications);
+
+    const outgoingRequests = sideADefinitions.requests.createClient({
+      request: outgoingRequest
+    });
+
+    const outgoingNotifications = sideADefinitions.notifications.createClient({
+      notify: outgoingNotify
+    });
+
+    return {
+      outgoingRequests: outgoingRequests /*as ReturnType<TSideARequests["createClient"]>*/,
+      outgoingNotifications: outgoingNotifications /*as ReturnType<TSideANotifications["createClient"]>*/,
+
+      handleIncomingRequest: handleRequest,
+      handleIncomingNotification: handleNotification
+    };
+  };
+
+  return {
+    sideA,
+    sideB
+  };
+};
+
+export { createCombined };

package/dist/lib/definitions/notification.d.ts

@@ -0,0 +1,32 @@
+import { type TObjectParser } from "./parser.js";
+import type { TJsonRpcParameters, TNotificationHandler, TNotifyMethod } from "../types.js";
+type RpcNotificationDefinition<TParams = unknown> = {
+    paramsParser: TObjectParser<TParams>;
+};
+type RpcNotificationsDefinitionMap = Record<string, RpcNotificationDefinition<any>>;
+type ExtractParserType<T> = T extends TObjectParser<infer U> ? U : never;
+type ServerHandlers<TMap extends RpcNotificationsDefinitionMap> = {
+    [K in keyof TMap]: (params: ExtractParserType<TMap[K]["paramsParser"]>) => void;
+};
+type ClientMethods<TMap extends RpcNotificationsDefinitionMap> = {
+    [K in keyof TMap]: (params: ExtractParserType<TMap[K]["paramsParser"]>) => void;
+};
+declare const createRpcNotificationsDefinition: <const TMap extends RpcNotificationsDefinitionMap>(definitions: TMap) => {
+    createServer: ({ notifications, handleUnknownNotification, handleParametersParseError }: {
+        notifications: ServerHandlers<TMap>;
+        handleUnknownNotification: TNotificationHandler;
+        handleParametersParseError: (args: {
+            method: string;
+            params: TJsonRpcParameters | undefined;
+            parseError: Error;
+        }) => void;
+    }) => {
+        handleNotification: TNotificationHandler;
+    };
+    createClient: ({ notify }: {
+        notify: TNotifyMethod;
+    }) => ClientMethods<TMap>;
+};
+type TRpcNotificationsDefinition<TMap extends RpcNotificationsDefinitionMap> = ReturnType<typeof createRpcNotificationsDefinition<TMap>>;
+export { createRpcNotificationsDefinition };
+export type { TRpcNotificationsDefinition };

package/dist/lib/definitions/notification.js

@@ -0,0 +1,95 @@
+import { /*type TObjectParser */} from "./parser.js";
+/*import type {
+  TJsonRpcParameters,
+  TNotificationHandler,
+  TNotifyMethod
+} from "../types.ts";*/
+
+/*type RpcNotificationDefinition<TParams = unknown> = {
+  paramsParser: TObjectParser<TParams>;
+};*/
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+/*type RpcNotificationsDefinitionMap = Record<string, RpcNotificationDefinition<any>>;*/
+
+/*type ExtractParserType<T> = T extends TObjectParser<infer U> ? U : never;*/
+
+/*type ServerHandlers<TMap extends RpcNotificationsDefinitionMap> = {
+  [K in keyof TMap]: (params: ExtractParserType<TMap[K]["paramsParser"]>) => void;
+};*/
+
+/*type ClientMethods<TMap extends RpcNotificationsDefinitionMap> = {
+  [K in keyof TMap]: (params: ExtractParserType<TMap[K]["paramsParser"]>) => void;
+};*/
+
+const createRpcNotificationsDefinition = /*<const TMap extends RpcNotificationsDefinitionMap>*/(
+  definitions/*: TMap*/
+) => {
+  const createServer = ({
+    notifications,
+    handleUnknownNotification,
+    handleParametersParseError
+  }/*: {
+    notifications: ServerHandlers<TMap>;
+    handleUnknownNotification: TNotificationHandler;
+    handleParametersParseError: (args: {
+      method: string;
+      params: TJsonRpcParameters | undefined;
+      parseError: Error;
+    }) => void;
+  }*/) => {
+    const handleNotification/*: TNotificationHandler*/ = ({ method, params }) => {
+      const definition = definitions[method];
+      if (!definition) {
+        handleUnknownNotification({ method, params });
+        return;
+      }
+
+      const parseResult = definition.paramsParser.parse({ raw: params });
+      if (parseResult.error) {
+        handleParametersParseError({
+          method,
+          params,
+          parseError: parseResult.error
+        });
+        return;
+      }
+
+      const handler = notifications[method /*as keyof TMap*/];
+      handler(parseResult.value /*as ExtractParserType<TMap[keyof TMap]["paramsParser"]>*/);
+    };
+
+    return {
+      handleNotification
+    };
+  };
+
+  const createClient = ({ notify }/*: { notify: TNotifyMethod }*/) => {
+    const client = {} /*as ClientMethods<TMap>*/;
+
+    for (const method of Object.keys(definitions) /*as Array<keyof TMap & string>*/) {
+      const definition = definitions[method];
+      (client /*as Record<string, unknown>*/)[method] = (params/*: unknown*/) => {
+        const formattedParams = definition.paramsParser.format({ value: params });
+        notify({ method, params: formattedParams /*as Record<string, unknown>*/ });
+      };
+    }
+
+    return client;
+  };
+
+  return {
+    createServer,
+    createClient
+  };
+};
+
+/*type TRpcNotificationsDefinition<TMap extends RpcNotificationsDefinitionMap> = ReturnType<
+  typeof createRpcNotificationsDefinition<TMap>
+>;*/
+
+export { createRpcNotificationsDefinition };
+
+/*export type {
+  TRpcNotificationsDefinition
+};*/

package/dist/lib/definitions/parser.d.ts

@@ -0,0 +1,16 @@
+type TObjectParseResult<T> = {
+    error: Error;
+    value: undefined;
+} | {
+    error: undefined;
+    value: T;
+};
+type TObjectParser<T> = {
+    parse: ({ raw }: {
+        raw: unknown;
+    }) => TObjectParseResult<T>;
+    format: ({ value }: {
+        value: T;
+    }) => unknown;
+};
+export type { TObjectParser, TObjectParseResult };

package/dist/lib/definitions/parser.js

@@ -0,0 +1,17 @@
+/*type TObjectParseResult<T> = {
+  error: Error;
+  value: undefined;
+} | {
+  error: undefined;
+  value: T;
+};*/
+
+/*type TObjectParser<T> = {
+  parse: ({ raw }: { raw: unknown }) => TObjectParseResult<T>;
+  format: ({ value }: { value: T }) => unknown;
+};*/
+
+/*export type {
+  TObjectParser,
+  TObjectParseResult
+};*/

package/dist/lib/definitions/requests.d.ts

@@ -0,0 +1,39 @@
+import { type TObjectParser } from "./parser.js";
+import type { TJsonRpcParameters, TRequestHandler, TRequestHandlerResponse, TRequestMethod } from "../types.js";
+type RpcRequestDefinition<TParams = unknown, TResult = unknown> = {
+    paramsParser: TObjectParser<TParams>;
+    resultParser: TObjectParser<TResult>;
+};
+type RpcRequestsDefinitionMap = Record<string, RpcRequestDefinition<any, any>>;
+type ExtractParserType<T> = T extends TObjectParser<infer U> ? U : never;
+type ServerHandlers<TMap extends RpcRequestsDefinitionMap> = {
+    [K in keyof TMap]: (params: ExtractParserType<TMap[K]["paramsParser"]>) => Promise<ExtractParserType<TMap[K]["resultParser"]>>;
+};
+type ClientMethods<TMap extends RpcRequestsDefinitionMap> = {
+    [K in keyof TMap]: (params: ExtractParserType<TMap[K]["paramsParser"]>) => Promise<{
+        error: Error;
+        result: undefined;
+    } | {
+        error: undefined;
+        result: ExtractParserType<TMap[K]["resultParser"]>;
+    }>;
+};
+declare const createRpcRequestsDefinition: <const TMap extends RpcRequestsDefinitionMap>(definitions: TMap) => {
+    createServer: ({ requests, handleUnknownRequest, handleParametersParseError }: {
+        requests: ServerHandlers<TMap>;
+        handleUnknownRequest: TRequestHandler;
+        handleParametersParseError: (args: {
+            method: string;
+            params: TJsonRpcParameters | undefined;
+            parseError: Error;
+        }) => Promise<TRequestHandlerResponse>;
+    }) => {
+        handleRequest: TRequestHandler;
+    };
+    createClient: ({ request }: {
+        request: TRequestMethod;
+    }) => ClientMethods<TMap>;
+};
+type TRpcRequestsDefinition<TMap extends RpcRequestsDefinitionMap> = ReturnType<typeof createRpcRequestsDefinition<TMap>>;
+export { createRpcRequestsDefinition };
+export type { TRpcRequestsDefinition };

package/dist/lib/definitions/requests.js

@@ -0,0 +1,134 @@
+import { /*type TObjectParser */} from "./parser.js";
+/*import type {
+  TJsonRpcParameters,
+  TRequestHandler,
+  TRequestHandlerResponse,
+  TRequestMethod,
+  TRequestResponseValue
+} from "../types.ts";*/
+
+/*type RpcRequestDefinition<TParams = unknown, TResult = unknown> = {
+  paramsParser: TObjectParser<TParams>;
+  resultParser: TObjectParser<TResult>;
+};*/
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+/*type RpcRequestsDefinitionMap = Record<string, RpcRequestDefinition<any, any>>;*/
+
+/*type ExtractParserType<T> = T extends TObjectParser<infer U> ? U : never;*/
+
+/*type ServerHandlers<TMap extends RpcRequestsDefinitionMap> = {
+  [K in keyof TMap]: (
+    params: ExtractParserType<TMap[K]["paramsParser"]>
+  ) => Promise<ExtractParserType<TMap[K]["resultParser"]>>;
+};*/
+
+/*type ClientMethods<TMap extends RpcRequestsDefinitionMap> = {
+  [K in keyof TMap]: (
+    params: ExtractParserType<TMap[K]["paramsParser"]>
+  ) => Promise<
+    | { error: Error; result: undefined }
+    | { error: undefined; result: ExtractParserType<TMap[K]["resultParser"]> }
+  >;
+};*/
+
+const createRpcRequestsDefinition = /*<const TMap extends RpcRequestsDefinitionMap>*/(
+  definitions/*: TMap*/
+) => {
+  const createServer = ({
+    requests,
+    handleUnknownRequest,
+    handleParametersParseError
+  }/*: {
+    requests: ServerHandlers<TMap>;
+    handleUnknownRequest: TRequestHandler;
+    handleParametersParseError: (args: {
+      method: string;
+      params: TJsonRpcParameters | undefined;
+      parseError: Error;
+    }) => Promise<TRequestHandlerResponse>;
+  }*/) => {
+    const handleRequest/*: TRequestHandler*/ = async ({ method, params }) => {
+      const definition = definitions[method];
+      if (!definition) {
+        return await handleUnknownRequest({ method, params });
+      }
+
+      const parseResult = definition.paramsParser.parse({ raw: params });
+      if (parseResult.error) {
+        return await handleParametersParseError({
+          method,
+          params,
+          parseError: parseResult.error
+        });
+      }
+
+      const handler = requests[method /*as keyof TMap*/];
+      const result = await handler(
+        parseResult.value /*as ExtractParserType<TMap[keyof TMap]["paramsParser"]>*/
+      );
+      const formattedResult = definition.resultParser.format({ value: result });
+
+      return {
+        result: formattedResult /*as TRequestResponseValue*/,
+        error: undefined
+      };
+    };
+
+    return {
+      handleRequest
+    };
+  };
+
+  const createClient = ({ request }/*: { request: TRequestMethod }*/) => {
+    const client = {} /*as ClientMethods<TMap>*/;
+
+    for (const method of Object.keys(definitions) /*as Array<keyof TMap & string>*/) {
+      const definition = definitions[method];
+      (client /*as Record<string, unknown>*/)[method] = async (params/*: unknown*/) => {
+        const formattedParams = definition.paramsParser.format({ value: params });
+        const { error: requestError, response } = await request({
+          method,
+          params: formattedParams /*as Record<string, unknown>*/
+        });
+        if (requestError !== undefined) {
+          return {
+            error: Error("failed to execute request", { cause: requestError }),
+            result: undefined
+          };
+        }
+        const { error: parseError, value } = definition.resultParser.parse({
+          raw: response.result
+        });
+        if (parseError !== undefined) {
+          return {
+            error: Error("failed to parse result", { cause: parseError }),
+            result: undefined
+          };
+        }
+
+        return {
+          error: undefined,
+          result: value
+        };
+      };
+    }
+
+    return client;
+  };
+
+  return {
+    createServer,
+    createClient
+  };
+};
+
+/*type TRpcRequestsDefinition<TMap extends RpcRequestsDefinitionMap> = ReturnType<
+  typeof createRpcRequestsDefinition<TMap>
+>;*/
+
+export { createRpcRequestsDefinition };
+
+/*export type {
+  TRpcRequestsDefinition
+};*/

package/dist/lib/index.d.ts

@@ -1,47 +1,8 @@
-import type { TJsonRpcError, TJsonRpcMessage, TJsonRpcParameters, TRequestResponse, TRequestResponseValue, TRequestResult } from "./types.js";
-type TRequestHandlerResponse = {
-    result: TRequestResponseValue;
-    error: undefined;
-} | {
-    result: undefined;
-    error: TJsonRpcError;
-} | {
-    result: undefined;
-    error: undefined;
-};
-type TRequestHandler = (args: {
-    method: string;
-    params: TJsonRpcParameters | undefined;
-}) => Promise<TRequestHandlerResponse>;
-type TNotificationHandler = (args: {
-    method: string;
-    params: TJsonRpcParameters | undefined;
-}) => void;
-type TNotifyMethod = (args: {
-    method: string;
-    params: TJsonRpcParameters;
-}) => void;
-type TRequestMethod = (args: {
-    method: string;
-    params: TJsonRpcParameters;
-    timeoutMs?: number;
-}) => Promise<TRequestResult>;
-declare const createJrpc: ({ sendMessage, handleRequest, handleNotification }: {
-    sendMessage: (args: {
-        message: TJsonRpcMessage;
-    }) => void;
-    handleRequest: TRequestHandler;
-    handleNotification: TNotificationHandler;
-}) => {
-    receivedMessage: ({ message }: {
-        message: unknown;
-    }) => {
-        error: Error | undefined;
-    };
-    request: TRequestMethod;
-    notify: TNotifyMethod;
-    close: () => void;
-};
-type TJrpc = ReturnType<typeof createJrpc>;
-export { createJrpc };
-export type { TJsonRpcMessage, TRequestResponse, TRequestResult, TJrpc, TRequestHandler, TNotificationHandler, TRequestMethod, TNotifyMethod };
+import { createJrpc } from "./jrpc.js";
+import { createWebSocketJrpc } from "./websocket.js";
+import { createRpcRequestsDefinition } from "./definitions/requests.js";
+import { createRpcNotificationsDefinition } from "./definitions/notification.js";
+import { createCombined } from "./definitions/combined.js";
+import type { TObjectParser } from "./definitions/parser.js";
+export { createJrpc, createWebSocketJrpc, createRpcRequestsDefinition, createRpcNotificationsDefinition, createCombined };
+export type { TObjectParser };