Integration of js-rpc timeout and middleware changes to fix Auth Provider timeout issue

package.json

@@ -77,7 +77,7 @@
     "@matrixai/mdns": "^1.2.3",
     "@matrixai/quic": "^1.1.1",
     "@matrixai/resources": "^1.1.5",
-    "@matrixai/rpc": "^0.2.4",
+    "@matrixai/rpc": "^0.4.1",
     "@matrixai/timer": "^1.1.2",
     "@matrixai/workers": "^1.3.7",
     "@matrixai/ws": "^1.1.7",

src/PolykeyClient.ts

@@ -297,7 +297,7 @@ class PolykeyClient {
         optionsDefaulted.rpcParserBufferSize,
       ),
       toError: networkUtils.toError,
-      streamKeepAliveTimeoutTime: optionsDefaulted.rpcCallTimeoutTime,
+      timeoutTime: optionsDefaulted.rpcCallTimeoutTime,
       logger: this.logger.getChild(RPCClient.name),
     });
     this._nodeId = nodeId_;

src/client/ClientService.ts

@@ -83,7 +83,7 @@ class ClientService {
     this.logger = logger ?? new Logger(this.constructor.name);
     this.rpcServer = new RPCServer({
       idGen,
-      handlerTimeoutTime: rpcCallTimeoutTime,
+      timeoutTime: rpcCallTimeoutTime,
       middlewareFactory: rpcMiddleware.defaultServerMiddlewareWrapper(
         middlewareFactory,
         rpcParserBufferSize,

src/client/authenticationMiddleware.ts

@@ -7,7 +7,10 @@ import type { ClientRPCRequestParams, ClientRPCResponseResult } from './types';
 import type { Session } from '../sessions';
 import type SessionManager from '../sessions/SessionManager';
 import type KeyRing from '../keys/KeyRing';
-import type { JSONRPCError, JSONRPCResponseError } from '@matrixai/rpc';
+import type {
+  JSONRPCResponseError,
+  JSONRPCResponseFailed,
+} from '@matrixai/rpc';
 import { TransformStream } from 'stream/web';
 import { authenticate, decodeAuth } from './utils';
 import { sysexits } from '../errors';
@@ -43,12 +46,12 @@ function authenticationMiddlewareServer(
               );
             } catch (e) {
               controller.error(e);
-              const rpcError: JSONRPCError = {
+              const rpcError: JSONRPCResponseError = {
                 code: e.exitCode ?? sysexits.UNKNOWN,
                 message: e.description ?? '',
                 data: networkUtils.fromError(e),
               };
-              const rpcErrorMessage: JSONRPCResponseError = {
+              const rpcErrorMessage: JSONRPCResponseFailed = {
                 jsonrpc: '2.0',
                 error: rpcError,
                 id: null,

src/client/handlers/IdentitiesAuthenticate.ts

@@ -20,6 +20,7 @@ class IdentitiesAuthenticate extends ServerHandler<
   }>,
   ClientRPCResponseResult<AuthProcessMessage>
 > {
+  public timeout = 120000; // 2 Minutes
   public async *handle(
     input: ClientRPCRequestParams<{
       providerId: string;

src/client/index.ts

@@ -5,6 +5,5 @@ export * as handlers from './handlers';
 export * as utils from './utils';
 export * as middleware from './middleware';
 export * as authenticationMiddleware from './authenticationMiddleware';
-export * as timeoutMiddleWare from './timeoutMiddleware';
 export * as errors from './errors';
 export * as types from './types';

src/client/middleware.ts

@@ -8,7 +8,6 @@ import type {
 import type SessionManager from '../sessions/SessionManager';
 import type KeyRing from '../keys/KeyRing';
 import * as authenticationMiddlewareUtils from './authenticationMiddleware';
-import * as timeoutMiddlewareUtils from './timeoutMiddleware';
 
 function middlewareServer(
   sessionManager: SessionManager,
@@ -26,24 +25,15 @@ function middlewareServer(
     );
   return (ctx, cancel, meta) => {
     const authMiddleware = authMiddlewareFactory(ctx, cancel, meta);
-    const timeoutMiddleware = timeoutMiddlewareUtils.timeoutMiddlewareServer(
-      ctx,
-      cancel,
-      meta,
-    );
     // Order is auth -> timeout
     return {
       forward: {
         writable: authMiddleware.forward.writable,
-        readable: authMiddleware.forward.readable.pipeThrough(
-          timeoutMiddleware.forward,
-        ),
+        readable: authMiddleware.forward.readable,
       },
       reverse: {
-        writable: timeoutMiddleware.reverse.writable,
-        readable: timeoutMiddleware.reverse.readable.pipeThrough(
-          authMiddleware.reverse,
-        ),
+        writable: authMiddleware.reverse.writable,
+        readable: authMiddleware.reverse.readable,
       },
     };
   };
@@ -61,24 +51,15 @@ function middlewareClient(
     authenticationMiddlewareUtils.authenticationMiddlewareClient(session);
   return (ctx, cancel, meta) => {
     const authMiddleware = authMiddlewareFactory(ctx, cancel, meta);
-    const timeoutMiddleware = timeoutMiddlewareUtils.timeoutMiddlewareClient(
-      ctx,
-      cancel,
-      meta,
-    );
     // Order is timeout -> auth
     return {
       forward: {
-        writable: timeoutMiddleware.forward.writable,
-        readable: timeoutMiddleware.forward.readable.pipeThrough(
-          authMiddleware.forward,
-        ),
+        writable: authMiddleware.forward.writable,
+        readable: authMiddleware.forward.readable,
       },
       reverse: {
         writable: authMiddleware.reverse.writable,
-        readable: authMiddleware.reverse.readable.pipeThrough(
-          timeoutMiddleware.reverse,
-        ),
+        readable: authMiddleware.reverse.readable,
       },
     };
   };

src/client/types.ts

@@ -1,4 +1,4 @@
-import type { JSONValue, ObjectEmpty } from '../types';
+import type { JSONObject, JSONRPCResponseResult } from '@matrixai/rpc';
 import type {
   GestaltIdEncoded,
   IdentityId,
@@ -17,28 +17,21 @@ import type {
 import type { Notification } from '../notifications/types';
 import type { ProviderToken } from '../identities/types';
 
-// Prevent overwriting the metadata type with `Omit<>`
-type ClientRPCRequestParams<T extends Record<string, JSONValue> = ObjectEmpty> =
-  {
-    metadata?: {
-      [Key: string]: JSONValue;
-    } & Partial<{
+type ClientRPCRequestParams<T extends JSONObject = JSONObject> =
+  JSONRPCResponseResult<
+    T,
+    Partial<{
       authorization: string;
-      timeout: number;
-    }>;
-  } & Omit<T, 'metadata'>;
-
-// Prevent overwriting the metadata type with `Omit<>`
-type ClientRPCResponseResult<
-  T extends Record<string, JSONValue> = ObjectEmpty,
-> = {
-  metadata?: {
-    [Key: string]: JSONValue;
-  } & Partial<{
-    authorization: string;
-    timeout: number;
-  }>;
-} & Omit<T, 'metadata'>;
+    }>
+  >;
+
+type ClientRPCResponseResult<T extends JSONObject = JSONObject> =
+  JSONRPCResponseResult<
+    T,
+    Partial<{
+      authorization: string;
+    }>
+  >;
 
 type StatusResultMessage = {
   pid: number;

src/nodes/NodeConnectionManager.ts

@@ -454,7 +454,7 @@ class NodeConnectionManager {
         this.rpcParserBufferSize,
       ),
       fromError: networkUtils.fromError,
-      handlerTimeoutTime: this.rpcCallTimeoutTime,
+      timeoutTime: this.rpcCallTimeoutTime,
       logger: this.logger.getChild(RPCServer.name),
     });
 

src/nodes/agent/handlers/VaultsGitInfoGet.ts

@@ -1,10 +1,10 @@
 import type { DB } from '@matrixai/db';
 import type Logger from '@matrixai/logger';
+import type { JSONObject, JSONRPCRequest } from '@matrixai/rpc';
 import type { ContextTimed } from '@matrixai/contexts';
 import type ACL from '../../../acl/ACL';
 import type VaultManager from '../../../vaults/VaultManager';
 import type { JSONValue } from '../../../types';
-import type { JSONRPCRequest } from '@matrixai/rpc';
 import { ReadableStream } from 'stream/web';
 import { RawHandler } from '@matrixai/rpc';
 import * as agentErrors from '../errors';
@@ -28,7 +28,7 @@ class VaultsGitInfoGet extends RawHandler<{
     _cancel,
     meta: Record<string, JSONValue> | undefined,
     _ctx: ContextTimed, // TODO: use
-  ): Promise<[JSONValue, ReadableStream<Uint8Array>]> => {
+  ): Promise<[JSONObject, ReadableStream<Uint8Array>]> => {
     const { db, vaultManager, acl } = this.container;
     const [headerMessage, inputStream] = input;
     await inputStream.cancel();

src/nodes/agent/handlers/VaultsGitPackGet.ts

@@ -1,10 +1,9 @@
 import type { DB } from '@matrixai/db';
+import type { JSONObject, JSONRPCRequest } from '@matrixai/rpc';
 import type { PassThrough } from 'readable-stream';
 import type { VaultName } from '../../../vaults/types';
 import type ACL from '../../../acl/ACL';
 import type VaultManager from '../../../vaults/VaultManager';
-import type { JSONValue } from '../../../types';
-import type { JSONRPCRequest } from '@matrixai/rpc';
 import { ReadableStream } from 'stream/web';
 import { RawHandler } from '@matrixai/rpc';
 import * as agentErrors from '../errors';
@@ -26,7 +25,7 @@ class VaultsGitPackGet extends RawHandler<{
     input: [JSONRPCRequest, ReadableStream<Uint8Array>],
     _cancel,
     meta,
-  ): Promise<[JSONValue, ReadableStream<Uint8Array>]> => {
+  ): Promise<[JSONObject, ReadableStream<Uint8Array>]> => {
     const { vaultManager, acl, db } = this.container;
     const [headerMessage, inputStream] = input;
     const requestingNodeId = agentUtils.nodeIdFromMeta(meta);
@@ -103,7 +102,7 @@ class VaultsGitPackGet extends RawHandler<{
         sideBand.destroy(e);
       },
     });
-    return [null, outputStream];
+    return [{}, outputStream];
   };
 }