@k13engineering/yajrpc 0.0.1

package/dist/lib/index.js

@@ -0,0 +1,255 @@
+import { coerceJrpcMessage } from "./coerce.js";
+/*import type { TJsonRpcError, TJsonRpcMandatoryId, TJsonRpcMessage, TJsonRpcParameters, TRequestResponse, TRequestResponseValue, TRequestResult } from "./types.ts";*/
+
+/*type TPendingRequestHandle = {
+  resolve: (args: TRequestResult) => void;
+};*/
+
+/*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>;*/
+
+const createJrpc = ({
+  sendMessage,
+  handleRequest,
+  handleNotification
+}/*: {
+  sendMessage: (args: { message: TJsonRpcMessage }) => void;
+  handleRequest: TRequestHandler;
+  handleNotification: TNotificationHandler;
+}*/) => {
+
+  let closed = false;
+
+  const receivedRequest = ({
+    id,
+    method,
+    params
+  }/*: {
+    id: TJsonRpcMandatoryId,
+    method: string,
+    params: TJsonRpcParameters | undefined
+  }*/)/*: { error: Error | undefined }*/ => {
+
+    handleRequest({ method, params }).then((response) => {
+
+      if (response.error !== undefined) {
+        sendMessage({
+          message: {
+            jsonrpc: "2.0",
+            id,
+            error: response.error
+          }
+        });
+        return;
+      }
+
+      if (response.result !== undefined) {
+        sendMessage({
+          message: {
+            jsonrpc: "2.0",
+            result: response.result,
+            id
+          }
+        });
+        return;
+      }
+
+      // send nothing if we neither have a result nor an error
+      // this is a valid case
+    });
+
+    return {
+      error: undefined
+    };
+  };
+
+  let pendingRequests/*: Record<string, TPendingRequestHandle>*/ = {};
+
+  const receivedResponse = ({ id, response }/*: { id: TJsonRpcMandatoryId, response: TRequestResponse }*/)/*: { error: Error | undefined }*/ => {
+    const pendingRequest = pendingRequests[id];
+    if (pendingRequest === undefined) {
+      return {
+        error: Error("received response for non-pending id")
+      };
+    }
+
+    pendingRequest.resolve({
+      response,
+      error: undefined
+    });
+
+    return {
+      error: undefined
+    };
+  };
+
+  // eslint-disable-next-line complexity
+  const receivedMessage = ({ message }/*: { message: unknown }*/)/*: { error: Error | undefined }*/ => {
+    if (closed) {
+      throw Error("connection closed");
+    }
+
+    const { error: coerceError, jrpcMessage } = coerceJrpcMessage({ message });
+    if (coerceError !== undefined) {
+      return {
+        error: coerceError
+      };
+    }
+
+    if (jrpcMessage.id === null) {
+      return {
+        error: Error("this library does not support null ids")
+      };
+    }
+
+    if (jrpcMessage.id === undefined) {
+      handleNotification({
+        method: jrpcMessage.method,
+        params: jrpcMessage.params
+      });
+
+      return { error: undefined };
+    }
+
+    if (jrpcMessage.result !== undefined) {
+      return receivedResponse({
+        id: jrpcMessage.id,
+        response: {
+          result: jrpcMessage.result,
+          error: undefined
+        }
+      });
+    }
+
+    if (jrpcMessage.error !== undefined) {
+      return receivedResponse({
+        id: jrpcMessage.id,
+        response: {
+          result: undefined,
+          error: jrpcMessage.error
+        }
+      });
+    }
+
+    return receivedRequest({
+      id: jrpcMessage.id,
+      method: jrpcMessage.method,
+      params: jrpcMessage.params
+    });
+  };
+
+  const close = () => {
+    if (closed) {
+      throw Error("connection already closed");
+    }
+
+    Object.keys(pendingRequests).forEach((id) => {
+      const pendingRequest = pendingRequests[id];
+      pendingRequest.resolve({
+        error: Error("connection closed"),
+        response: undefined
+      });
+    });
+
+    closed = true;
+  };
+
+  let requestIdCounter = 0;
+
+  const request/*: TRequestMethod*/ = ({
+    method,
+    params,
+    timeoutMs
+  })/*: Promise<TRequestResult>*/ => {
+
+    const requestId = requestIdCounter;
+    requestIdCounter += 1;
+
+    let timeoutHandle/*: NodeJS.Timeout | undefined*/ = undefined;
+    if (timeoutMs !== undefined) {
+      timeoutHandle = setTimeout(() => {
+        const pendingRequest = pendingRequests[requestId];
+        pendingRequest.resolve({
+          error: Error("timeout"),
+          response: undefined
+        });
+      }, timeoutMs);
+    }
+
+    sendMessage({
+      message: {
+        jsonrpc: "2.0",
+        method,
+        params,
+        id: requestId
+      }
+    });
+
+    return new Promise((resolve) => {
+      pendingRequests = {
+        ...pendingRequests,
+        [requestId]: {
+          resolve: (result) => {
+            // remove the request from the pending requests
+            const { [requestId]: requestToDrop, ...otherPendingRequests } = pendingRequests;
+            pendingRequests = otherPendingRequests;
+
+            // clear the timeout
+            clearTimeout(timeoutHandle);
+
+            resolve(result);
+          },
+          timeoutHandle
+        }
+      };
+    });
+  };
+
+  const notify/*: TNotifyMethod*/ = ({ method, params }) => {
+    sendMessage({
+      message: {
+        jsonrpc: "2.0",
+        method,
+        params
+      }
+    });
+  };
+
+  return {
+    receivedMessage,
+    request,
+    notify,
+    close
+  };
+};
+
+/*type TJrpc = ReturnType<typeof createJrpc>;*/
+
+export {
+  createJrpc
+};
+
+/*export type {
+  TJsonRpcMessage,
+  TRequestResponse,
+  TRequestResult,
+  TJrpc,
+  TRequestHandler,
+  TNotificationHandler,
+  TRequestMethod,
+  TNotifyMethod
+};*/

package/dist/lib/types.d.ts

@@ -0,0 +1,68 @@
+type TJsonRpcParameterValue = Exclude<unknown, undefined>;
+type TRequestResponseValue = NonNullable<unknown> | null;
+type TJsonRpcParameters = Array<TJsonRpcParameterValue> | Record<string, TJsonRpcParameterValue>;
+type TJsonRpcOptionalId = string | number | null;
+type TJsonRpcMandatoryId = string | number;
+type TJsonRpcError = {
+    code: number;
+    message: string;
+    data?: unknown;
+};
+type TJsonRpcRequest = {
+    jsonrpc: "2.0";
+    id: TJsonRpcOptionalId;
+    method: string;
+    params?: TJsonRpcParameters;
+    result?: undefined;
+    error?: undefined;
+};
+type TJsonRpcNotification = {
+    jsonrpc: "2.0";
+    id?: undefined;
+    method: string;
+    params?: TJsonRpcParameters;
+    result?: undefined;
+    error?: undefined;
+};
+type TJsonRpcSuccessResponse = {
+    jsonrpc: "2.0";
+    id: TJsonRpcMandatoryId;
+    method?: undefined;
+    params?: undefined;
+    result: TRequestResponseValue;
+    error?: undefined;
+};
+type TJsonRpcErrorResponse = {
+    jsonrpc: "2.0";
+    id: TJsonRpcOptionalId;
+    method?: undefined;
+    params?: undefined;
+    result?: undefined;
+    error: TJsonRpcError;
+};
+type TJsonRpcResponse = TJsonRpcSuccessResponse | TJsonRpcErrorResponse;
+type TJsonRpcMessage = TJsonRpcRequest | TJsonRpcNotification | TJsonRpcResponse;
+type TRequestErrorResponse = {
+    result?: never;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    ignore?: never;
+};
+type TRequestResponse = {
+    error: TJsonRpcError;
+    result: undefined;
+} | {
+    error: undefined;
+    result: TRequestResponseValue;
+};
+type TRequestResult = {
+    error: Error;
+    response: undefined;
+} | {
+    error: undefined;
+    response: TRequestResponse;
+};
+export type { TJsonRpcRequest, TJsonRpcResponse, TJsonRpcNotification, TJsonRpcSuccessResponse, TJsonRpcErrorResponse, TJsonRpcMessage, TJsonRpcParameters, TJsonRpcOptionalId, TJsonRpcMandatoryId, TRequestResponse, TRequestResult, TRequestErrorResponse, TRequestResponseValue, TJsonRpcError, };

package/dist/lib/types.js

@@ -0,0 +1,98 @@
+/* c8 ignore start */
+/*type TJsonRpcParameterValue = Exclude<unknown, undefined>;*/
+/*type TRequestResponseValue = NonNullable<unknown> | null;*/
+
+/*type TJsonRpcParameters = Array<TJsonRpcParameterValue> | Record<string, TJsonRpcParameterValue>;*/
+
+/*type TJsonRpcOptionalId = string | number | null;*/
+/*type TJsonRpcMandatoryId = string | number;*/
+
+/*type TJsonRpcError = {
+  code: number;
+  message: string;
+  data?: unknown;
+};*/
+
+/*type TJsonRpcRequest = {
+  jsonrpc: "2.0";
+  id: TJsonRpcOptionalId;
+  method: string;
+  params?: TJsonRpcParameters;
+  result?: undefined;
+  error?: undefined;
+};*/
+
+/*type TJsonRpcNotification = {
+  jsonrpc: "2.0";
+  id?: undefined;
+  method: string;
+  params?: TJsonRpcParameters;
+  result?: undefined;
+  error?: undefined;
+};*/
+
+/*type TJsonRpcSuccessResponse = {
+  jsonrpc: "2.0";
+  id: TJsonRpcMandatoryId;
+  method?: undefined;
+  params?: undefined;
+  result: TRequestResponseValue;
+  error?: undefined;
+};*/
+
+/*type TJsonRpcErrorResponse = {
+  jsonrpc: "2.0";
+  id: TJsonRpcOptionalId;
+  method?: undefined;
+  params?: undefined;
+  result?: undefined;
+  error: TJsonRpcError;
+};*/
+
+/*type TJsonRpcResponse = TJsonRpcSuccessResponse | TJsonRpcErrorResponse;*/
+
+/*type TJsonRpcMessage = TJsonRpcRequest | TJsonRpcNotification | TJsonRpcResponse;*/
+
+/*type TRequestErrorResponse = {
+  result?: never;
+  error: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+  ignore?: never;
+};*/
+
+/*type TRequestResponse = {
+  error: TJsonRpcError;
+  result: undefined;
+} | {
+  error: undefined;
+  result: TRequestResponseValue;
+};*/
+
+/*type TRequestResult = {
+  error: Error;
+  response: undefined;
+} | {
+  error: undefined;
+  response: TRequestResponse;
+};*/
+
+/*export type {
+  TJsonRpcRequest,
+  TJsonRpcResponse,
+  TJsonRpcNotification,
+  TJsonRpcSuccessResponse,
+  TJsonRpcErrorResponse,
+  TJsonRpcMessage,
+  TJsonRpcParameters,
+  TJsonRpcOptionalId,
+  TJsonRpcMandatoryId,
+  TRequestResponse,
+  TRequestResult,
+  TRequestErrorResponse,
+  TRequestResponseValue,
+  TJsonRpcError,
+};*/
+/* c8 ignore end */

package/package.json

@@ -0,0 +1,47 @@
+{
+  "version": "0.0.1",
+  "name": "@k13engineering/yajrpc",
+  "type": "module",
+  "description": "Boilerplate project",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/lib/index.js",
+  "scripts": {
+    "build": "rm -rf dist/ && deno-node-build --root . --out dist/ --entry lib/index.ts",
+    "type-check": "tsc --noEmit",
+    "test": "c8 --reporter lcov --reporter html --reporter text --all --src lib/ --exclude lib/snippets/ --exclude test/ mocha test/**/*.ts",
+    "lint": "eslint .",
+    "update-deps": "npm-check-updates -u"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@k13engineering/releasetool": "^0.0.5",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^25.0.10",
+    "c8": "^10.1.3",
+    "deno-node": "^0.0.12",
+    "mocha": "^11.7.5",
+    "npm-check-updates": "^19.3.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.1"
+  },
+  "dependencies": {},
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/k13-engineering/yajrpc.git"
+  },
+  "keywords": [
+    "node",
+    "jrpc"
+  ],
+  "author": "Simon Kadisch",
+  "license": "LGPL 2.1",
+  "bugs": {
+    "url": "https://github.com/k13-engineering/yajrpc/issues"
+  },
+  "homepage": "https://github.com/k13-engineering/yajrpc#readme"
+}