Merge pull request #219 from movesthatmatter/dev

Release v1.6

.storybook/main.ts

@@ -0,0 +1,12 @@
+import type { StorybookConfig } from '@storybook/core-common';
+
+export const rootMain: StorybookConfig = {
+  stories: [],
+  addons: ['@storybook/addon-essentials'],
+  // webpackFinal: async (config, { configType }) => {
+  //   // Make whatever fine-grained changes you need that should apply to all storybook configs
+
+  //   // Return the altered config
+  //   return config;
+  // },
+};

.storybook/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../tsconfig.base.json",
+  "exclude": [
+    "../**/*.spec.js",
+    "../**/*.test.js",
+    "../**/*.spec.ts",
+    "../**/*.test.ts",
+    "../**/*.spec.tsx",
+    "../**/*.test.tsx",
+    "../**/*.spec.jsx",
+    "../**/*.test.jsx"
+  ],
+  "include": ["../**/*"]
+}

apps/movex-demo/pages/chat/[chatId].tsx

@@ -1,4 +1,4 @@
-import { useMovexBoundResourceFromRid, useMovexClientId } from 'movex-react';
+import { useMovexBoundResourceFromRid, useMovexClient } from 'movex-react';
 import { useRouter } from 'next/router';
 import { useMemo } from 'react';
 import { toResourceIdentifierObj } from 'movex-core-util';
@@ -20,7 +20,7 @@ const ChatSystem: React.FC<Props> = () => {
 
   // TODO: Validate the rid is correct inside useMovexBoundResouce
   const boundResource = useMovexBoundResourceFromRid(movexConfig, rid);
-  const userId = useMovexClientId(movexConfig);
+  const userId = useMovexClient(movexConfig)?.id;
 
   if (!(boundResource && userId)) {
     return null;

apps/movex-docs/pages/_meta.json

@@ -24,5 +24,9 @@
   "about": {
     "title": "About",
     "type": "page"
+  },
+  "changelog": {
+    "title": "Changelog",
+    "type": "page"
   }
 }

apps/movex-docs/pages/changelog.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## v0.1.6 (Sep 26 2024)
+
+### New Features
+- [x] Master Actions. [See  Pull Request](https://github.com/movesthatmatter/movex/pull/216).
+- [x] State Transformers. [See Pull Request](https://github.com/movesthatmatter/movex/pull/218).
+- [x] Add ability to disconenect an older client connection (for same client id) in favor of the newer one
+
+### Improvements
+- [x] Improve the Connection Events. [See Pull Request](https://github.com/movesthatmatter/movex/pull/220).
+
+### Bug Fixes
+- [x] State not re-synching after a forwardAction checksum mismatch.
+
+### Breaking
+- none
+
+## v0.1.5 (July 11 2024)
+- [x] Add ability to pass in Client Info Object and sync it to all peers
+- [x] Improve Logs

changelog.md

@@ -0,0 +1 @@
+apps/movex-docs/pages/changelog.md

libs/movex-core-util/package.json

@@ -1,6 +1,6 @@
 {
   "name": "movex-core-util",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Movex Core Util is the library of utilities for Movex",
   "license": "MIT",
   "author": {

libs/movex-core-util/src/index.ts

@@ -2,11 +2,10 @@ export * from './lib/misc';
 export * from './lib/domain';
 export * from './lib/Observable/Observable';
 export * from './lib/EventEmitter';
-export * from './lib/ScketIOEmitter';
 export * from './lib/Logsy';
 export * from './lib/action';
 export * from './lib/reducer';
 export * from './lib/core-types';
 export * from './lib/public-types';
 export * from './lib/checkedState';
-export * from './lib/io';
+export * from './lib/masterContext';

libs/movex-core-util/src/lib/EventEmitter.ts → libs/movex-core-util/src/lib/EventEmitter/EventEmitter.ts

@@ -1,5 +1,5 @@
 import type { EventMap } from 'typed-emitter';
-import type { EmptyFn } from './core-types';
+import type { EmptyFn } from '../core-types';
 
 export const emptyFn: EmptyFn = () => {};
 
@@ -34,4 +34,9 @@ export interface EventEmitter<TEventMap extends EventMap> {
     event: E,
     request: Parameters<TEventMap[E]>[0]
   ): Promise<ReturnType<TEventMap[E]>>;
+
+  disconnect(): void;
+
+  onConnect(fn: () => void): EmptyFn;
+  onDisconnect(fn: () => void): EmptyFn;
 }

libs/movex-core-util/src/lib/io/IOEvents.ts → libs/movex-core-util/src/lib/EventEmitter/IOEvents.ts

@@ -11,9 +11,10 @@ import type {
   IOPayloadResult,
   MovexClient,
   ResourceIdentifier,
-  ResourceIdentifierStr,
   SanitizedMovexClient,
 } from '../core-types';
+import { MovexMasterContext } from '../masterContext';
+// import { MovexMasterContext } from '../reducer';
 
 export type IOEvents<
   TState = unknown,
@@ -72,37 +73,49 @@ export type IOEvents<
     rid: ResourceIdentifier<TResourceType>;
     action: ActionOrActionTupleFromAction<A>;
   }) => IOPayloadResult<
-    | {
-        reconciled?: false;
-        nextChecksum: Checksum;
-      }
-    | ({
-        reconciled: true;
-      } & CheckedReconciliatoryActions<A>),
+    (
+      | {
+          type: 'ack';
+          nextChecksum: Checksum;
+        }
+      | {
+          type: 'masterActionAck';
+          // nextChecksum: Checksum;
+          nextCheckedAction: ToCheckedAction<A>;
+        }
+      | ({
+          type: 'reconciliation';
+        } & CheckedReconciliatoryActions<A>)
+    ) & {
+      masterContext: MovexMasterContext;
+    },
     'MasterResourceInexistent' | string
   >; // Type the other errors
 
   /**
    * The following events are directed from Master to Client
    * */
-  // @deprecate in favor ofClientReady
-  setClientId: (clientId: string) => void;
+  onReady: (p: SanitizedMovexClient) => void;
 
-  onClientReady: (client: SanitizedMovexClient) => void;
+  // onClockSync: (p: undefined) => IOPayloadResult<number, unknown>; // acknowledges the client timestamp
 
   onFwdAction: (
     payload: {
       rid: ResourceIdentifier<TResourceType>;
+      masterContext: MovexMasterContext;
     } & ToCheckedAction<A>
   ) => IOPayloadResult<void, unknown>;
   onReconciliateActions: (
     payload: {
       rid: ResourceIdentifier<TResourceType>;
+      masterContext: MovexMasterContext;
     } & CheckedReconciliatoryActions<A>
   ) => IOPayloadResult<void, unknown>;
   onResourceSubscriberAdded: (p: {
     rid: ResourceIdentifier<TResourceType>;
-    client: Pick<MovexClient, 'id' | 'info'>;
+    client: SanitizedMovexClient;
+    // TODO: Make required after it works
+    masterContext: MovexMasterContext;
     // clientId: MovexClient['id'];
   }) => IOPayloadResult<
     void,
@@ -120,6 +133,7 @@ export type IOEvents<
    * The following events are by-directional (from Client to Master and vice-versa)
    * */
 
+  // They need to be different than ping/pong because those are native to socket.io
   ping: () => IOPayloadResult<void, unknown>;
   pong: () => IOPayloadResult<void, unknown>;
 };

libs/movex-core-util/src/lib/ScketIOEmitter.ts → libs/movex-core-util/src/lib/EventEmitter/ScketIOEmitter.ts

@@ -1,25 +1,33 @@
 import { Err, Ok } from 'ts-results';
-import { globalLogsy } from './Logsy';
+import { globalLogsy } from '../Logsy';
 import type { Socket as ServerSocket } from 'socket.io';
 import type { Socket as ClientSocket } from 'socket.io-client';
 import type { EventMap } from 'typed-emitter';
 import type { EventEmitter } from './EventEmitter';
-import type { UnsubscribeFn, WsResponseResultPayload } from './core-types';
+import type { UnsubscribeFn, WsResponseResultPayload } from '../core-types';
 
 export type SocketIO = ServerSocket | ClientSocket;
 
 const logsy = globalLogsy.withNamespace('[SocketIOEmitter]');
 
-export class SocketIOEmitter<TEventMap extends EventMap>
-  implements EventEmitter<TEventMap>
+export class SocketIOEmitter<
+  TEventMap extends EventMap,
+  TSocketIO extends SocketIO = ServerSocket | ClientSocket
+> implements EventEmitter<TEventMap>
 {
+  protected config: {
+    waitForResponseMs: number;
+  };
+
   constructor(
-    private socket: SocketIO,
-    private config: {
+    protected socket: TSocketIO,
+    config?: {
       waitForResponseMs?: number;
-    } = {}
+    }
   ) {
-    this.config.waitForResponseMs = this.config.waitForResponseMs || 15 * 1000;
+    this.config = {
+      waitForResponseMs: config?.waitForResponseMs || 15 * 1000,
+    };
   }
 
   on<E extends keyof TEventMap>(
@@ -149,8 +157,36 @@ export class SocketIOEmitter<TEventMap extends EventMap>
       );
     }).catch((e) => e) as any;
   }
+
+  onConnect(fn: () => void) {
+    this.socket.on('connect', fn);
+
+    return () => {
+      this.socket.off('connect', fn);
+    };
+  }
+
+  onDisconnect(fn: () => void) {
+    this.socket.on('disconnect', fn);
+
+    return () => {
+      this.socket.off('disconnect', fn);
+    };
+  }
+
+  disconnect(): void {
+    this.socket.disconnect();
+  }
 }
 
+/**
+ * TODO: Deprecate this in favor of using the native timeout See https://socket.io/docs/v4/emitting-events/#with-timeout
+ *
+ * @param onSuccess
+ * @param onTimeout
+ * @param timeout
+ * @returns
+ */
 const withTimeout = (
   onSuccess: (...args: any[]) => void,
   onTimeout: () => void,

libs/movex-core-util/src/lib/EventEmitter/index.ts

@@ -0,0 +1,3 @@
+export * from './EventEmitter';
+export * from './IOEvents';
+export * from './ScketIOEmitter';

libs/movex-core-util/src/lib/action.ts

@@ -5,6 +5,13 @@ import { isObject, keyInObject } from './misc';
 
 // TODO: ith the new Reducer Refactoring, all of the action with collection map and generic actions can be removed I believe
 
+/**
+ * TODO: 18.08.2024 - This file needs a restructuring:
+ * - there are too many types, many of them aren't used or are intersecting with others
+ * - others are just confusing and create more issues in understanding (AnyAction vs GenericAction - which one is what???)
+ * - others are remnants of long past times (e..g all of the action with collection map and generic actions can be removed I believe)
+ */
+
 export type BaseAction<
   TType extends string,
   TPayload = undefined
@@ -27,9 +34,20 @@ export type PublicAction<
   isPrivate?: false;
 };
 
+export type MasterAction<TType extends string, TPayload = undefined> =
+  | (PrivateAction<TType, TPayload> & {
+      _isMaster: true; // Note: This is only meant for internal useage
+    })
+  | (PublicAction<TType, TPayload> & {
+      _isMaster: true; // Note: This is only meant for internal useage
+    });
+
 export type Action<TType extends string, TPayload = undefined> =
   | PublicAction<TType, TPayload>
-  | PrivateAction<TType, TPayload>;
+  | PrivateAction<TType, TPayload>
+  | MasterAction<TType, TPayload>;
+
+export type AnyMasterAction = MasterAction<string>;
 
 export type ActionWithAnyPayload<TType extends string> = Action<TType, unknown>;
 
@@ -56,10 +74,14 @@ export type AnyPublicActionOf<
 
 export type GenericPrivateAction = PrivateAction<string, unknown>;
 export type GenericPublicAction = PublicAction<string, unknown>;
+export type GenericMasterAction = MasterAction<string, unknown>;
 
-export type GenericAction = GenericPrivateAction | GenericPublicAction;
+export type GenericAction =
+  | GenericPrivateAction
+  | GenericPublicAction
+  | GenericMasterAction;
 
-export type AnyAction = Action<string>;
+export type AnyAction = Action<string> | GenericAction;
 
 export type UnknownAction = Action<string, unknown>;
 
@@ -99,6 +121,10 @@ export type ToPublicAction<A extends AnyAction> = A & {
   isPrivate?: false;
 };
 
+export type ToMasterAction<A extends AnyAction> = A & {
+  _isMaster: true;
+};
+
 export type CheckedReconciliatoryActions<A extends AnyAction> = {
   actions: ToPublicAction<A>[];
   finalChecksum: Checksum;
@@ -144,7 +170,7 @@ export type ActionCreatorsMapBase = {
   [k in string]: ReturnType<typeof createActionCreator>;
 };
 
-export type ActionTupleFrom<TAction extends AnyAction> = [
+export type ActionTupleFrom<TAction extends AnyAction | AnyMasterAction> = [
   ToPrivateAction<TAction>,
   ToPublicAction<TAction>
 ];
@@ -267,6 +293,42 @@ export function createActionCreator<
   });
 }
 
-export const isAction = (a: unknown): a is AnyAction => {
+export const isAction = (
+  a: ActionOrActionTupleFromAction<AnyAction> | AnyAction
+): a is AnyAction => {
+  // TODO: This isn't a super thorough check, but if the input is limited
+  //  to only action or ActionTuple should be enough
   return isObject(a) && keyInObject(a, 'type');
 };
+
+export const isMasterAction = (
+  a: ActionOrActionTupleFromAction<AnyAction> | AnyAction
+): a is AnyMasterAction => {
+  // TODO: This isn't a super thorough check, but if the input is limited
+  //  to only action or ActionTuple should be enough
+  return isAction(a) && keyInObject(a, '_isMaster') && a._isMaster === true;
+};
+
+export const toMasterAction = <TAction extends AnyAction>(
+  action: TAction
+): ToMasterAction<TAction> => ({
+  ...action,
+  _isMaster: true,
+});
+
+export const toMasterActionFromActionOrTuple = <TAction extends AnyAction>(
+  actionOrActionTuple: ActionOrActionTupleFromAction<TAction>
+) => {
+  return (
+    isAction(actionOrActionTuple)
+      ? toMasterAction(actionOrActionTuple)
+      : // TODO: In the case of a tuple, there is not enough information
+        //  so I'm just making them both a masterAction, but I should only make the one that is needed actually
+        // - this isn't the worst possible thing as if there's nothing to parse nothing will parse
+        // and the client will simply attempt to run again with the same
+        [
+          toMasterAction(actionOrActionTuple[0]),
+          toMasterAction(actionOrActionTuple[1]),
+        ]
+  ) as ActionOrActionTupleFromAction<ToMasterAction<TAction>>;
+};