syntax: fixed middleware utils imports

[ci skip]

Author: tegefaulkes

src/PolykeyAgent.ts

@@ -12,8 +12,8 @@ import { DB } from '@matrixai/db';
 import { CreateDestroyStartStop } from '@matrixai/async-init/dist/CreateDestroyStartStop';
 import RPCServer from './rpc/RPCServer';
 import WebSocketServer from './websockets/WebSocketServer';
-import * as rpcMiddlewareUtils from './rpc/utils/middleware';
-import * as clientMiddleware from './client/utils/middleware';
+import * as rpcUtilsMiddleware from './rpc/utils/middleware';
+import * as clientUtilsMiddleware from './client/utils/middleware';
 import { WorkerManager } from './workers';
 import * as networkUtils from './network/utils';
 import KeyRing from './keys/KeyRing';
@@ -437,8 +437,8 @@ class PolykeyAgent {
             sessionManager: sessionManager,
             vaultManager: vaultManager,
           }),
-          middlewareFactory: rpcMiddlewareUtils.defaultServerMiddlewareWrapper(
-            clientMiddleware.middlewareServer(sessionManager, keyRing),
+          middlewareFactory: rpcUtilsMiddleware.defaultServerMiddlewareWrapper(
+            clientUtilsMiddleware.middlewareServer(sessionManager, keyRing),
           ),
           sensitive: false,
           logger: logger.getChild('RPCServerClient'),

src/PolykeyClient.ts

@@ -4,8 +4,8 @@ import path from 'path';
 import Logger from '@matrixai/logger';
 import { CreateDestroyStartStop } from '@matrixai/async-init/dist/CreateDestroyStartStop';
 import RPCClient from './rpc/RPCClient';
-import * as rpcMiddlewareUtils from './rpc/utils/middleware';
-import * as clientMiddleware from './client/utils/middleware';
+import * as rpcUtilsMiddleware from './rpc/utils/middleware';
+import * as clientUtilsMiddleware from './client/utils/middleware';
 import { Session } from './sessions';
 import * as errors from './errors';
 import * as utils from './utils';
@@ -61,8 +61,8 @@ class PolykeyClient<M extends ClientManifest> {
             manifest,
             streamFactory,
             middlewareFactory:
-              rpcMiddlewareUtils.defaultClientMiddlewareWrapper(
-                clientMiddleware.middlewareClient(session),
+              rpcUtilsMiddleware.defaultClientMiddlewareWrapper(
+                clientUtilsMiddleware.middlewareClient(session),
               ),
             logger: logger.getChild(RPCClient.name),
           });

src/rpc/RPCClient.ts

@@ -23,7 +23,7 @@ import { CreateDestroy, ready } from '@matrixai/async-init/dist/CreateDestroy';
 import Logger from '@matrixai/logger';
 import { IdInternal } from '@matrixai/id';
 import { Timer } from '@matrixai/timer';
-import * as middlewareUtils from './utils/middleware';
+import * as rpcUtilsMiddleware from './utils/middleware';
 import * as rpcErrors from './errors';
 import * as rpcUtils from './utils/utils';
 import { never, promise } from '../utils';
@@ -50,7 +50,7 @@ class RPCClient<M extends ClientManifest> {
   static async createRPCClient<M extends ClientManifest>({
     manifest,
     streamFactory,
-    middlewareFactory = middlewareUtils.defaultClientMiddlewareWrapper(),
+    middlewareFactory = rpcUtilsMiddleware.defaultClientMiddlewareWrapper(),
     streamKeepAliveTimeoutTime = 60_000, // 1 minute
     logger = new Logger(this.name),
   }: {

src/rpc/RPCServer.ts

@@ -30,7 +30,7 @@ import {
 import * as rpcEvents from './events';
 import * as rpcUtils from './utils/utils';
 import * as rpcErrors from './errors';
-import * as middlewareUtils from './utils/middleware';
+import * as rpcUtilsMiddleware from './utils/middleware';
 import { never } from '../utils/utils';
 import { sysexits } from '../errors';
 
@@ -69,7 +69,7 @@ class RPCServer extends EventTarget {
    */
   public static async createRPCServer({
     manifest,
-    middlewareFactory = middlewareUtils.defaultServerMiddlewareWrapper(),
+    middlewareFactory = rpcUtilsMiddleware.defaultServerMiddlewareWrapper(),
     sensitive = false,
     streamKeepAliveTimeoutTime = 60_000, // 1 minute
     timeoutForceCloseTime = 2_000, // 2 seconds
@@ -435,7 +435,7 @@ class RPCServer extends EventTarget {
     });
 
     const prom = (async () => {
-      const headTransformStream = middlewareUtils.binaryToJsonMessageStream(
+      const headTransformStream = rpcUtilsMiddleware.binaryToJsonMessageStream(
         rpcUtils.parseJSONRPCRequest,
       );
       // Transparent transform used as a point to cancel the input stream from

tests/client/authenticationMiddleware.test.ts

@@ -19,7 +19,7 @@ import * as clientRPCUtils from '@/client/utils';
 import * as authMiddleware from '@/client/utils/authenticationMiddleware';
 import { UnaryCaller } from '@/rpc/callers';
 import { UnaryHandler } from '@/rpc/handlers';
-import * as middlewareUtils from '@/rpc/utils/middleware';
+import * as rpcUtilsMiddleware from '@/rpc/utils/middleware';
 import WebSocketServer from '@/websockets/WebSocketServer';
 import WebSocketClient from '@/websockets/WebSocketClient';
 import * as testsUtils from '../utils';
@@ -107,7 +107,7 @@ describe('authenticationMiddleware', () => {
       manifest: {
         testHandler: new EchoHandler({ logger }),
       },
-      middlewareFactory: middlewareUtils.defaultServerMiddlewareWrapper(
+      middlewareFactory: rpcUtilsMiddleware.defaultServerMiddlewareWrapper(
         authMiddleware.authenticationMiddlewareServer(sessionManager, keyRing),
       ),
       logger,
@@ -134,7 +134,7 @@ describe('authenticationMiddleware', () => {
         >(),
       },
       streamFactory: async () => clientClient.startConnection(),
-      middlewareFactory: middlewareUtils.defaultClientMiddlewareWrapper(
+      middlewareFactory: rpcUtilsMiddleware.defaultClientMiddlewareWrapper(
         authMiddleware.authenticationMiddlewareClient(session),
       ),
       logger,

tests/client/handlers/agentUnlock.test.ts

@@ -13,8 +13,8 @@ import { AgentUnlockHandler } from '@/client/handlers/agentUnlock';
 import RPCClient from '@/rpc/RPCClient';
 import { Session, SessionManager } from '@/sessions';
 import * as clientUtils from '@/client/utils';
-import * as authMiddleware from '@/client/utils/authenticationMiddleware';
-import * as middlewareUtils from '@/rpc/utils/middleware';
+import * as clientUtilsAuthMiddleware from '@/client/utils/authenticationMiddleware';
+import * as rpcUtilsMiddleware from '@/rpc/utils/middleware';
 import WebSocketServer from '@/websockets/WebSocketServer';
 import WebSocketClient from '@/websockets/WebSocketClient';
 import { agentUnlock } from '@/client';
@@ -92,8 +92,11 @@ describe('agentUnlock', () => {
       manifest: {
         agentUnlock: new AgentUnlockHandler({}),
       },
-      middlewareFactory: middlewareUtils.defaultServerMiddlewareWrapper(
-        authMiddleware.authenticationMiddlewareServer(sessionManager, keyRing),
+      middlewareFactory: rpcUtilsMiddleware.defaultServerMiddlewareWrapper(
+        clientUtilsAuthMiddleware.authenticationMiddlewareServer(
+          sessionManager,
+          keyRing,
+        ),
       ),
       logger,
     });
@@ -115,8 +118,8 @@ describe('agentUnlock', () => {
         agentUnlock,
       },
       streamFactory: async () => clientClient.startConnection(),
-      middlewareFactory: middlewareUtils.defaultClientMiddlewareWrapper(
-        authMiddleware.authenticationMiddlewareClient(session),
+      middlewareFactory: rpcUtilsMiddleware.defaultClientMiddlewareWrapper(
+        clientUtilsAuthMiddleware.authenticationMiddlewareClient(session),
       ),
       logger,
     });

tests/client/timeoutMiddleware.test.ts

@@ -19,7 +19,7 @@ import RPCClient from '@/rpc/RPCClient';
 import * as timeoutMiddleware from '@/client/utils/timeoutMiddleware';
 import { UnaryCaller } from '@/rpc/callers';
 import { UnaryHandler } from '@/rpc/handlers';
-import * as middlewareUtils from '@/rpc/utils/middleware';
+import * as rpcUtilsMiddleware from '@/rpc/utils/middleware';
 import WebSocketServer from '@/websockets/WebSocketServer';
 import WebSocketClient from '@/websockets/WebSocketClient';
 import { promise } from '@/utils';
@@ -100,7 +100,7 @@ describe('timeoutMiddleware', () => {
       manifest: {
         testHandler: new EchoHandler({ logger }),
       },
-      middlewareFactory: middlewareUtils.defaultServerMiddlewareWrapper(
+      middlewareFactory: rpcUtilsMiddleware.defaultServerMiddlewareWrapper(
         timeoutMiddleware.timeoutMiddlewareServer,
       ),
       logger,
@@ -127,7 +127,7 @@ describe('timeoutMiddleware', () => {
         >(),
       },
       streamFactory: async () => clientClient.startConnection(),
-      middlewareFactory: middlewareUtils.defaultClientMiddlewareWrapper(
+      middlewareFactory: rpcUtilsMiddleware.defaultClientMiddlewareWrapper(
         timeoutMiddleware.timeoutMiddlewareClient,
       ),
       logger,
@@ -160,7 +160,7 @@ describe('timeoutMiddleware', () => {
       manifest: {
         testHandler: new EchoHandler({ logger }),
       },
-      middlewareFactory: middlewareUtils.defaultServerMiddlewareWrapper(
+      middlewareFactory: rpcUtilsMiddleware.defaultServerMiddlewareWrapper(
         timeoutMiddleware.timeoutMiddlewareServer,
       ),
       streamKeepAliveTimeoutTime: 100,
@@ -188,7 +188,7 @@ describe('timeoutMiddleware', () => {
         >(),
       },
       streamFactory: async () => clientClient.startConnection(),
-      middlewareFactory: middlewareUtils.defaultClientMiddlewareWrapper(
+      middlewareFactory: rpcUtilsMiddleware.defaultClientMiddlewareWrapper(
         timeoutMiddleware.timeoutMiddlewareClient,
       ),
       logger,

tests/rpc/RPC.test.ts

@@ -23,7 +23,7 @@ import {
   UnaryCaller,
 } from '@/rpc/callers';
 import * as rpcErrors from '@/rpc/errors';
-import * as rpcMiddlewareUtils from '@/rpc/utils/middleware';
+import * as rpcUtilsMiddleware from '@/rpc/utils/middleware';
 import * as rpcTestUtils from './utils';
 
 describe('RPC', () => {
@@ -367,7 +367,7 @@ describe('RPC', () => {
         yield* input;
       }
     }
-    const middleware = rpcMiddlewareUtils.defaultServerMiddlewareWrapper(() => {
+    const middleware = rpcUtilsMiddleware.defaultServerMiddlewareWrapper(() => {
       return {
         forward: new TransformStream({
           start: (controller) => {

tests/rpc/RPCClient.test.ts

@@ -20,7 +20,7 @@ import {
   ServerCaller,
   UnaryCaller,
 } from '@/rpc/callers';
-import * as middlewareUtils from '@/rpc/utils/middleware';
+import * as rpcUtilsMiddleware from '@/rpc/utils/middleware';
 import { promise, sleep } from '@/utils/index';
 import * as rpcTestUtils from './utils';
 
@@ -364,7 +364,7 @@ describe(`${RPCClient.name}`, () => {
       const rpcClient = await RPCClient.createRPCClient({
         manifest: {},
         streamFactory: async () => streamPair,
-        middlewareFactory: middlewareUtils.defaultClientMiddlewareWrapper(
+        middlewareFactory: rpcUtilsMiddleware.defaultClientMiddlewareWrapper(
           () => {
             return {
               forward: new TransformStream<JSONRPCRequest, JSONRPCRequest>({
@@ -430,7 +430,7 @@ describe(`${RPCClient.name}`, () => {
       const rpcClient = await RPCClient.createRPCClient({
         manifest: {},
         streamFactory: async () => streamPair,
-        middlewareFactory: middlewareUtils.defaultClientMiddlewareWrapper(
+        middlewareFactory: rpcUtilsMiddleware.defaultClientMiddlewareWrapper(
           () => {
             return {
               forward: new TransformStream(),
@@ -1111,7 +1111,7 @@ describe(`${RPCClient.name}`, () => {
             ctxProm.resolveP(ctx);
             return streamPair;
           },
-          middlewareFactory: middlewareUtils.defaultClientMiddlewareWrapper(
+          middlewareFactory: rpcUtilsMiddleware.defaultClientMiddlewareWrapper(
             (ctx) => {
               ctx.timer.reset(1000);
               return {

tests/rpc/RPCServer.test.ts

@@ -23,7 +23,7 @@ import {
   ServerHandler,
   UnaryHandler,
 } from '@/rpc/handlers';
-import * as middlewareUtils from '@/rpc/utils/middleware';
+import * as rpcUtilsMiddleware from '@/rpc/utils/middleware';
 import { promise, sleep } from '@/utils';
 import * as rpcTestUtils from './utils';
 
@@ -583,7 +583,7 @@ describe(`${RPCServer.name}`, () => {
         yield* input;
       }
     }
-    const middlewareFactory = middlewareUtils.defaultServerMiddlewareWrapper(
+    const middlewareFactory = rpcUtilsMiddleware.defaultServerMiddlewareWrapper(
       () => {
         return {
           forward: new TransformStream({
@@ -630,7 +630,7 @@ describe(`${RPCServer.name}`, () => {
         yield* input;
       }
     }
-    const middleware = middlewareUtils.defaultServerMiddlewareWrapper(() => {
+    const middleware = rpcUtilsMiddleware.defaultServerMiddlewareWrapper(() => {
       return {
         forward: new TransformStream(),
         reverse: new TransformStream({
@@ -678,36 +678,38 @@ describe(`${RPCServer.name}`, () => {
           yield* input;
         }
       }
-      const middleware = middlewareUtils.defaultServerMiddlewareWrapper(() => {
-        let first = true;
-        let reverseController: TransformStreamDefaultController<JSONRPCResponse>;
-        return {
-          forward: new TransformStream<
-            JSONRPCRequest<TestType>,
-            JSONRPCRequest<TestType>
-          >({
-            transform: (chunk, controller) => {
-              if (first && chunk.params?.metadata.token !== validToken) {
-                reverseController.enqueue(failureMessage);
-                // Closing streams early
-                controller.terminate();
-                reverseController.terminate();
-              }
-              first = false;
-              controller.enqueue(chunk);
-            },
-          }),
-          reverse: new TransformStream({
-            start: (controller) => {
-              // Kidnapping reverse controller
-              reverseController = controller;
-            },
-            transform: (chunk, controller) => {
-              controller.enqueue(chunk);
-            },
-          }),
-        };
-      });
+      const middleware = rpcUtilsMiddleware.defaultServerMiddlewareWrapper(
+        () => {
+          let first = true;
+          let reverseController: TransformStreamDefaultController<JSONRPCResponse>;
+          return {
+            forward: new TransformStream<
+              JSONRPCRequest<TestType>,
+              JSONRPCRequest<TestType>
+            >({
+              transform: (chunk, controller) => {
+                if (first && chunk.params?.metadata.token !== validToken) {
+                  reverseController.enqueue(failureMessage);
+                  // Closing streams early
+                  controller.terminate();
+                  reverseController.terminate();
+                }
+                first = false;
+                controller.enqueue(chunk);
+              },
+            }),
+            reverse: new TransformStream({
+              start: (controller) => {
+                // Kidnapping reverse controller
+                reverseController = controller;
+              },
+              transform: (chunk, controller) => {
+                controller.enqueue(chunk);
+              },
+            }),
+          };
+        },
+      );
       const rpcServer = await RPCServer.createRPCServer({
         manifest: {
           testMethod: new TestMethod({}),
@@ -1050,15 +1052,14 @@ describe(`${RPCServer.name}`, () => {
           yield* input;
         }
       }
-      const middlewareFactory = middlewareUtils.defaultServerMiddlewareWrapper(
-        (ctx) => {
+      const middlewareFactory =
+        rpcUtilsMiddleware.defaultServerMiddlewareWrapper((ctx) => {
           ctx.timer.reset(12345);
           return {
             forward: new TransformStream(),
             reverse: new TransformStream(),
           };
-        },
-      );
+        });
       const rpcServer = await RPCServer.createRPCServer({
         manifest: {
           testMethod: new TestMethod({}),