fix(reactant-share): fix delegate action sequence issue (#142)

Author: unadlib

packages/reactant-share/src/delegate.ts

@@ -1,4 +1,5 @@
-import { containerKey, identifierKey, Service } from 'reactant';
+/* eslint-disable consistent-return */
+import { containerKey, identifierKey, Service, watch } from 'reactant';
 import { proxyClientActionName, proxyExecutorKey } from './constants';
 import type { ProxyExec, ProxyExecutor } from './interfaces';
 import { PortDetector } from './modules/portDetector';
@@ -92,18 +93,46 @@ export const delegate = ((module, key, args, options = {}) => {
           )
         );
       }
-      return portDetector.transports.client.emit(
-        {
-          ...options,
-          name: proxyClientActionName,
-        },
-        {
-          module: target[identifierKey]!,
-          method: key,
-          args: _args,
-          hook: options._extra?.serverHook,
-        }
-      );
+      return portDetector.transports.client
+        .emit(
+          {
+            ...options,
+            name: proxyClientActionName,
+          },
+          {
+            module: target[identifierKey]!,
+            method: key,
+            args: _args,
+            hook: options._extra?.serverHook,
+          }
+        )
+        .then((response) => {
+          // If the response is undefined, it means that the method is not executed.
+          if (!response) return;
+          const [sequence, result] = response;
+          if (portDetector.lastAction.sequence >= sequence) {
+            return result;
+          }
+          if (__DEV__) {
+            console.warn(
+              `The sequence of the action is not consistent.`,
+              sequence,
+              portDetector.lastAction.sequence
+            );
+          }
+          return new Promise((resolve) => {
+            const unwatch = watch(
+              portDetector,
+              () => portDetector.lastAction.sequence,
+              () => {
+                if (portDetector.lastAction.sequence >= sequence) {
+                  unwatch();
+                  resolve(result);
+                }
+              }
+            );
+          });
+        });
     }
   }
   return (method as Function).apply(target, _args);

packages/reactant-share/src/interfaces.ts

@@ -155,7 +155,7 @@ export interface ProxyExecParams {
 }
 
 export type ClientEvents = {
-  [proxyClientActionName](options: ProxyExecParams): Promise<any>;
+  [proxyClientActionName](options: ProxyExecParams): Promise<[number, any]>;
   [preloadedStateActionName](): Promise<Record<string, any>>;
   [loadFullStateActionName](
     sequence: number

packages/reactant-share/src/server.ts

@@ -57,11 +57,14 @@ export const handleServer = ({
       if (options.hook) {
         const hook = portDetector.serverHooks[options.hook];
         if (typeof hook === 'function') {
-          return hook(options);
+          const result = await hook(options);
+          const { sequence } = portDetector.lastAction;
+          return [sequence, result];
         }
       }
       const result = await applyMethod(app, options);
-      return result;
+      const { sequence } = portDetector.lastAction;
+      return [sequence, result];
     })
   );
   disposeListeners.push(() => transport.dispose());