@lvce-editor/json-rpc 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,3 +1,26 @@
-export const invoke: (method: string, ...params: any[]) => Promise<any>
+export const send: (ipc: any, method: string, ...params: any[]) => void
+
+export const invoke: (
+  ipc: any,
+  method: string,
+  ...params: any[]
+) => Promise<any>
+
+export const invokeAndTransfer: (
+  ipc: any,
+  transfer: any,
+  method: string,
+  ...params: any[]
+) => Promise<any>
 
 export const resolve: (id: number, message: any) => void
+
+export const handleJsonRpcMessage: (
+  ipc: any,
+  message: any,
+  execute: (method: string, ...params: any[]) => Promise<any>,
+  resolve: any,
+  preparePrettyError: (error: any) => Promise<any>,
+  logError: (error: any) => void,
+  requiresSocket: (method: string) => void,
+) => Promise<void>

package/dist/index.js

@@ -1,6 +1,6 @@
 const Two = '2.0';
 
-const create$2 = (method, params) => {
+const create$4 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -8,14 +8,55 @@ const create$2 = (method, params) => {
   }
 };
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+
+const getType = (value) => {
+  switch (typeof value) {
+    case 'number':
+      return 'number'
+    case 'function':
+      return 'function'
+    case 'string':
+      return 'string'
+    case 'object':
+      if (value === null) {
+        return 'null'
+      }
+      if (Array.isArray(value)) {
+        return 'array'
+      }
+      return 'object'
+    case 'boolean':
+      return 'boolean'
+    default:
+      return 'unknown'
+  }
+};
+
+const number = (value) => {
+  const type = getType(value);
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number')
+  }
+};
+
 const state$1 = {
   id: 0,
 };
 
-const create$1 = () => {
+const create$3 = () => {
   return ++state$1.id
 };
 
+const warn = (...args) => {
+  console.warn(...args);
+};
+
 const withResolvers = () => {
   /**
    * @type {any}
@@ -41,13 +82,24 @@ const state = {
 };
 
 const registerPromise = () => {
-  const id = create$1();
+  const id = create$3();
   const { resolve, promise } = withResolvers();
   state.callbacks[id] = resolve;
   return { id, promise }
 };
 
-const create = (method, params) => {
+const resolve = (id, args) => {
+  number(id);
+  if (!(id in state.callbacks)) {
+    console.log(args);
+    warn(`callback ${id} may already be disposed`);
+    return
+  }
+  state.callbacks[id](args);
+  delete state.callbacks[id];
+};
+
+const create$2 = (method, params) => {
   const { id, promise } = registerPromise();
   const message = {
     jsonrpc: Two,
@@ -117,6 +169,7 @@ const joinLines = (lines) => {
 };
 
 const MethodNotFound = -32601;
+const Custom = -32001;
 
 const splitLines = (lines) => {
   return lines.split(NewLine)
@@ -210,13 +263,142 @@ const unwrapJsonRpcResult = (responseMessage) => {
   throw new JsonRpcError('unexpected response message')
 };
 
+const create$1 = (message, error) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    error,
+  }
+};
+
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      message: error.message,
+      data: error.stack,
+    }
+  }
+  return {
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: prettyError.stack,
+      codeFrame: prettyError.codeFrame,
+      type: prettyError.type,
+      code: prettyError.code,
+    },
+  }
+};
+
+const getErrorResponse = (
+  message,
+  error,
+  ipc,
+  preparePrettyError,
+  logError,
+) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1(message, errorProperty)
+};
+
+const create = (message, result) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    result: result ?? null,
+  }
+};
+
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create(message, resultProperty)
+};
+
+const getResponse = async (
+  message,
+  ipc,
+  execute,
+  preparePrettyError,
+  logError,
+  requiresSocket,
+) => {
+  try {
+    const result = requiresSocket(message.method)
+      ? await execute(message.method, ipc, ...message.params)
+      : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result)
+  } catch (error) {
+    return getErrorResponse(
+      message,
+      error,
+      ipc,
+      preparePrettyError,
+      logError,
+    )
+  }
+};
+
+const handleJsonRpcMessage = async (
+  ipc,
+  message,
+  execute,
+  resolve,
+  preparePrettyError,
+  logError,
+  requiresSocket,
+) => {
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(
+        message,
+        ipc,
+        execute,
+        preparePrettyError,
+        logError,
+        requiresSocket,
+      );
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(
+          message,
+          error,
+          ipc,
+          preparePrettyError,
+          logError,
+        );
+        ipc.send(errorResponse);
+      }
+      return
+    }
+    resolve(message.id, message);
+    return
+  }
+  if ('method' in message) {
+    await getResponse(
+      message,
+      ipc,
+      execute,
+      preparePrettyError,
+      logError,
+    );
+    return
+  }
+  throw new JsonRpcError('unexpected message')
+};
+
 const send = (transport, method, ...params) => {
-  const message = create$2(method, params);
+  const message = create$4(method, params);
   transport.send(message);
 };
 
 const invoke = async (ipc, method, ...params) => {
-  const { message, promise } = create(method, params);
+  const { message, promise } = create$2(method, params);
   ipc.send(message);
   const responseMessage = await promise;
   const result = unwrapJsonRpcResult(responseMessage);
@@ -224,11 +406,11 @@ const invoke = async (ipc, method, ...params) => {
 };
 
 const invokeAndTransfer = async (ipc, handle, method, ...params) => {
-  const { message, promise } = create(method, params);
+  const { message, promise } = create$2(method, params);
   ipc.sendAndTransfer(message, handle);
   const responseMessage = await promise;
   const result = unwrapJsonRpcResult(responseMessage);
   return result
 };
 
-export { invoke, invokeAndTransfer, send };
+export { handleJsonRpcMessage, invoke, invokeAndTransfer, resolve, send };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/json-rpc",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "JsonRpc implementation",
   "main": "dist/index.js",
   "type": "module",