chore(server): change server message handling to handle result for mo…

…re cases
PeculiarVentures · Jan 24, 2024 · 3c5084a · 3c5084a
1 parent 1bebede
commit 3c5084a
Show file tree

Hide file tree

Showing 3 changed files with 35 additions and 39 deletions.
diff --git a/packages/server/src/connection/events/message.ts b/packages/server/src/connection/events/message.ts
@@ -9,7 +9,13 @@ export class ServerMessageEvent extends ServerEvent {
   public resolve: (result: proto.ResultProto) => void;
   public reject: (error: Error) => void;
 
-  constructor(target: Server, session: Session, message: proto.ActionProto, resolve: () => void, reject: (error: Error) => void) {
+  constructor(
+    target: Server,
+    session: Session,
+    message: proto.ActionProto,
+    resolve: (result: proto.ResultProto) => void,
+    reject: (error: Error) => void,
+  ) {
     super(target, "message");
     this.message = message;
     this.session = session;

diff --git a/packages/server/src/connection/server.ts b/packages/server/src/connection/server.ts
@@ -16,6 +16,14 @@ import { RatchetStorage } from "./storages";
 
 export interface ServerOptions extends HttpsServerOptions {
   storage: RatchetStorage;
+  /**
+   * Prepares server for message handling (auth, validation, setup, etc.).
+   */
+  onMessagePrepare?: (session: Session, action: proto.ActionProto) => Promise<unknown>;
+  /**
+   * Performs post-processing tasks after server message handling.
+   */
+  onMessageResult?: (resolved: boolean, error?: Error) => unknown
 }
 
 type AlgorithmUsageType = "generateKey" | "importKey" | "exportKey" | "sign" | "verify" | "deriveKey" | "deriveBits" | "encrypt" | "decrypt" | "wrapKey" | "unwrapKey" | "digest";
@@ -98,7 +106,7 @@ export class Server extends core.EventLogEmitter {
 
   protected httpServer!: https.Server;
   protected socketServer!: WebSocket.Server;
-  protected options: HttpsServerOptions;
+  protected options: ServerOptions;
 
   constructor(options: ServerOptions) {
     super();
@@ -256,6 +264,18 @@ export class Server extends core.EventLogEmitter {
             const actionProto = await proto.ActionProto.importProto(decryptedMessage);
 
             return new Promise<proto.ResultProto>((resolve, reject) => {
+              const handleResolve = (reason: proto.ResultProto) => {
+                if (this.options.onMessageResult) {
+                  this.options.onMessageResult(true);
+                }
+                resolve(reason);
+              };
+              const handleReject = (reason: Error) => {
+                if (this.options.onMessageResult) {
+                  this.options.onMessageResult(false, reason);
+                }
+                reject(reason);
+              };
               if (
                 session.authorized ||
                 actionProto.action === proto.ServerIsLoggedInActionProto.ACTION ||
@@ -265,6 +285,9 @@ export class Server extends core.EventLogEmitter {
                   if (!session.cipher) {
                     throw new Error("Session cipher was not initialized yet");
                   }
+                  if (this.options.onMessagePrepare) {
+                    await this.options.onMessagePrepare(session, actionProto);
+                  }
                   const sessionIdentitySHA256 = await session.cipher.remoteIdentity.signingKey.thumbprint();
                   if (new RegExp("^crypto\/").test(actionProto.action)) {
                     const cryptoActionProto = await proto.CryptoActionProto.importProto(actionProto);
@@ -279,10 +302,11 @@ export class Server extends core.EventLogEmitter {
                       action: actionProto.action,
                     });
                   }
-                  this.emit("message", new events.ServerMessageEvent(this, session, actionProto, resolve as any, reject));
+                  this.emit("message", new events.ServerMessageEvent(this, session, actionProto, handleResolve, handleReject));
                 })()
                   .catch((err) => {
-                    this.emit("error", err);
+                    this.emit("error", new events.ServerErrorEvent(this, err));
+                    handleReject(err);
                   });
               } else {
                 // If session is not authorized throw error

diff --git a/packages/server/src/server.ts b/packages/server/src/server.ts
@@ -13,14 +13,6 @@ export interface IServerOptions extends ServerOptions {
    * Disables using of PCSC. No emit CardReader and Provider token events
    */
   disablePCSC?: boolean;
-  /**
-   * Prepares server for message handling (auth, validation, setup, etc.).
-   */
-  onMessagePrepare?: (session: Session, action: proto.ActionProto) => Promise<unknown>;
-  /**
-   * Performs post-processing tasks after server message handling.
-   */
-  onMessageResult?: (resolved: boolean, error?: Error) => unknown
 }
 
 /**
@@ -46,15 +38,10 @@ export class LocalServer extends core.EventLogEmitter {
   public provider: ProviderService;
   public cardReader?: CardReaderService;
 
-  private onMessagePrepareHandler: IServerOptions['onMessagePrepare'];
-  private onMessageResultHandler: IServerOptions['onMessageResult'];
-
   constructor(options: IServerOptions) {
     super();
 
     this.server = new Server(options);
-    this.onMessagePrepareHandler = options.onMessagePrepare || Promise.resolve;
-    this.onMessageResultHandler = options.onMessageResult || function () { };
 
     if (!options.disablePCSC) {
       this.cardReader = new CardReaderService(this.server)
@@ -138,34 +125,13 @@ export class LocalServer extends core.EventLogEmitter {
       })
       .on("message", (e) => {
         (async () => {
-          if (this.onMessagePrepareHandler) {
-            await this.onMessagePrepareHandler(e.session, e.message);
-          }
-
           if (e.message.action === proto.ServerIsLoggedInActionProto.ACTION ||
             e.message.action === proto.ServerLoginActionProto.ACTION) {
-            const onResolve = (reason: proto.ResultProto) => {
-              if (this.onMessageResultHandler) {
-                this.onMessageResultHandler(true);
-              }
-              e.resolve(reason);
-            };
-            const onReject = (reason: Error) => {
-              if (this.onMessageResultHandler) {
-                this.onMessageResultHandler(false, reason);
-              }
-              e.reject(reason);
-            };
-
             this.onMessage(e.session, e.message)
-              .then(onResolve, onReject)
+              .then(e.resolve, e.reject)
           }
         })()
           .catch((error) => {
-            if (this.onMessageResultHandler) {
-              this.onMessageResultHandler(false, error);
-            }
-            e.reject(error);
             this.emit("error", error);
           });
       })