bug fixes

Author: RodrigoBertotti

src/client_middleware/Clients.ts

@@ -44,7 +44,8 @@ export type RouteBeingListen = {
   listenId: string;
   params;
   locals;
-  authenticationStatus:"authenticatedOrNot" | "authenticatedOnly"
+  authenticationStatus:"authenticatedOrNot" | "authenticatedOnly";
+  at: Date
 };
 /** @internal */
 export class ClientInfo {
@@ -96,6 +97,8 @@ export class Clients {
   constructor(public readonly askless:AsklessServer) {}
 
   stopListening(clientInfo: ClientInfo, listenId: string) {
+    this.askless.logger("stopListening #1: "+(clientInfo.userId ?? '') + '  ' + listenId, "debug");
+
     const routeBeingListen = clientInfo.routesBeingListen.find(
       (s) => s.listenId == listenId
     );
@@ -176,15 +179,6 @@ export class Clients {
     delete this.clientIdInternalApp_clientInfo[clientIdInternalApp];
   }
 
-  // getClientByUserId(userId: USER_ID) : ClientInfo | null {
-  //   for (const clientIdInternalApp of Object.keys(this.clientIdInternalApp_clientInfo)) {
-  //     const client = this.clientIdInternalApp_clientInfo[clientIdInternalApp];
-  //     if (client.userId.toString() == userId.toString()) {
-  //       return client;
-  //     }
-  //   }
-  //   return null;
-  // }
   getClientInfoByUserId(userId) {
     return Object.values(this.clientIdInternalApp_clientInfo).find((item:ClientInfo )=> item.userId == userId);
   }

src/client_middleware/ws/onMessage/ReceiveMessageHandler/ConfigureConnectionRequestHandler.ts

@@ -54,6 +54,7 @@ export class ConfigureConnectionRequestHandler {
         };
         clientInfo.onClose = () => {
             this.askless.logger("onClose websocket " + clientWsEndpoint[ws_clientIdInternalApp], "debug");
+            this.askless.logger("stopListening #2 (on close websocket): "+(clientInfo.userId ?? ''), "debug");
 
             Array.from(clientInfo.routesBeingListen).forEach((routeBeingListen) => {
                this.askless.getReadRoute(routeBeingListen.route).stopListening(clientInfo.clientIdInternalApp, routeBeingListen.listenId, routeBeingListen.route);

src/client_middleware/ws/onMessage/ReceiveMessageHandler/ReceiveMessageHandler.ts

@@ -207,7 +207,7 @@ class _RunModifyOperationInApp extends _RunOperationInApp {
     if (route.authenticationStatus == "authenticatedOnly" && clientInfo.authentication != "authenticated") {
       res = new AsklessError({
         code: AsklessErrorCode.PENDING_AUTHENTICATION,
-        description: "Could not perform the operation on ("+route.requestType+") \""+route.route+"\" because authentication is required",
+        description: "Could not perform the operation on ("+route.requestType+") \""+route.route+"\" because authentication is required, but user authentication is "+clientInfo.authentication,
       });
     } else if (data.requestType == RequestType.DELETE) {
       res = await (route as DeleteRoute<any, any, AuthenticateUserContext<any>>).deletePromise(params);

src/index.ts

@@ -248,7 +248,7 @@ export class AsklessServer<USER_ID = string | number> {
     if (config.authenticate == null) {
       config.authenticate = async (_, accept) => { accept.asUnauthenticatedUser(); }
     }
-    config["reconnectClientAfterMillisecondsWithoutServerPong"] = 6 * 1000;
+    config["reconnectClientAfterMillisecondsWithoutServerPong"] = 6 * 1000; // TODO: add type to configuration
     config[
         "intervalInMillsecondsCheckIfIsNeededToClearRuntimeDataFromDisconnectedClient"
     ] = 53 * 1000; //(10x + 3 intervalInSecondsClientPong) in this way, the client can still receive the responde in case he disconnects

src/route/ReadRoute.ts

@@ -324,26 +324,36 @@ abstract class _ReadRoute<ENTITY, LOGGED_IN_OR_NOT, LOCALS extends (Authenticate
     //   return;
     // }
     return new Promise<String|undefined>(async (resolve) => {
-      this.stopListening(  clientIdInternalApp, listenId, this.route);
-      const clientInfo = this.askless.clientMiddleware.clients.getOrCreateClientInfo(  clientIdInternalApp);
+      this.askless.logger("listen @internal "+listenId, "debug");
+
+      const clientInfo = this.askless.clientMiddleware.clients.getOrCreateClientInfo(clientIdInternalApp);
       // const start = Date.now();
       const locals = Object.assign({}, clientInfo.locals);
 
-      clientInfo.routesBeingListen.push({
-        clientIdInternalApp: clientIdInternalApp,
-        listenId: listenId,
-        route: this.route,
-        params: params,
-        locals: locals,
-        authenticationStatus: this.authenticationStatus,
-      });
-
+      if (listenId) {
+        const existingIndex = clientInfo.routesBeingListen.findIndex((c) => c.listenId == listenId);
+        const prev = existingIndex != -1 ? clientInfo.routesBeingListen[existingIndex] : {};
+        const data = Object.assign(prev, {
+          clientIdInternalApp: clientIdInternalApp,
+          listenId: listenId,
+          route: this.route,
+          params: params,
+          locals: locals,
+          authenticationStatus: this.authenticationStatus,
+          at: new Date(),
+        });
+        if (existingIndex != -1) {
+          clientInfo.routesBeingListen[existingIndex] = data;
+        } else {
+          clientInfo.routesBeingListen.push(data);
+        }
+      }
       let _getEntity: () => ENTITY;
       let response;
       if (this.authenticationStatus == "authenticatedOnly" && clientInfo.authentication != "authenticated") {
         response = new AsklessError({
           code: AsklessErrorCode.PENDING_AUTHENTICATION,
-          description: "Could not perform the operation on (LISTEN) \""+this.route+"\" because authentication is required",
+          description: "Could not perform the operation on (LISTEN) \""+this.route+"\" because authentication is required, but user authentication is "+clientInfo.authentication,
         });
       } else {
         response = await this.readInternal({
@@ -384,7 +394,8 @@ abstract class _ReadRoute<ENTITY, LOGGED_IN_OR_NOT, LOCALS extends (Authenticate
         );
         if (error?.code == AsklessErrorCode.PERMISSION_DENIED || error?.code == AsklessErrorCode.PENDING_AUTHENTICATION) {
           this.askless.logger("listen: the error is \""+error.code+"\", calling stopListening...", "error", error);
-          this.stopListening(  clientIdInternalApp, listenId, this.route);
+          this.askless.logger("stopListening #4", "debug");
+          await this.stopListening(  clientIdInternalApp, listenId, this.route);
           this.askless.logger("onClientStartsListening not called", "error");
         }
         resolve(undefined);
@@ -461,10 +472,10 @@ abstract class _ReadRoute<ENTITY, LOGGED_IN_OR_NOT, LOCALS extends (Authenticate
   toOutput(entity: ENTITY):any {};
 
   /** @internal */
-  stopListening(clientIdInternalApp: string,
+  async stopListening(clientIdInternalApp: string,
     listenId?:string,
-    route?: string
-  ): void {
+    route?: string,
+  ): Promise<void> {
     if (clientIdInternalApp == null) throw Error("clientIdInternalApp is undefined");
     if (listenId == null && route != null)
       throw Error("please, inform the listenId");
@@ -483,19 +494,21 @@ abstract class _ReadRoute<ENTITY, LOGGED_IN_OR_NOT, LOCALS extends (Authenticate
     if (!remove.length){
       this.askless.logger("stopListening: NO item for "+(this.route ?? 'unknown route') + " listenId: "+listenId + '  ' +JSON.stringify(clientInfo.routesBeingListen.map(e => e.listenId + " ("+e.route+")")), "debug");
     }
-    remove.forEach(async (p) => {
-      const context:AuthenticateUserContext<any> & ClientAndRouteContext = {
-        userId: clientInfo.userId,
-        claims: clientInfo.claims,
-        locals: p.locals,
-        params: p.params,
-      };
-      await this.onClientStopsListening(context as any);
-    });
-    remove.forEach((r) => {
-          clientInfo.routesBeingListen.splice(clientInfo.routesBeingListen.indexOf(r), 1);
-        }
-    );
+    for (let r=0;r<remove.length;r++){
+      clientInfo.routesBeingListen.splice(clientInfo.routesBeingListen.indexOf(remove[r]), 1);
+    }
+    for (let r=0;r<remove.length;r++){
+      const p = remove[r];
+      if (!clientInfo.routesBeingListen.find((r => r.route == p.route))) {
+        const context: AuthenticateUserContext<any> & ClientAndRouteContext = {
+          userId: clientInfo.userId,
+          claims: clientInfo.claims,
+          locals: p.locals,
+          params: p.params,
+        };
+        await this.onClientStopsListening(context as any);
+      }
+    }
   }
 }