Namespaces

examples/simpleActions.tests.ts → examples/actions.tests.ts

@@ -4,8 +4,8 @@ import { map } from 'rxjs/operators';
 import { createActionCreator, ExtractPayload } from 'rxbeach';
 import { ofType, extractPayload } from 'rxbeach/operators';
 
-describe('example', function() {
-  describe('simple actions', function() {
+export default function actionExamples() {
+  describe('actions', function() {
     const voidAction = createActionCreator('[test] void action');
     const primitiveAction = createActionCreator<number>(
       '[test] primitive action'
@@ -47,4 +47,4 @@ describe('example', function() {
     const payload_assignable_to_extracted: Extracted = (null as any) as Payload;
     const extracted_assignable_to_payload: Payload = (null as any) as Extracted;
   });
-});
+}

examples/index.tests.ts

@@ -0,0 +1,7 @@
+import actionExamples from './actions.tests';
+import namespaceExamples from './namespace.tests';
+
+describe('examples', function() {
+  actionExamples();
+  namespaceExamples();
+});

examples/namespace.tests.ts

@@ -0,0 +1,61 @@
+import { equal, deepEqual } from 'assert';
+import { of, Subject } from 'rxjs';
+import { reduce } from 'rxjs/operators';
+import {
+  createActionCreator,
+  namespaceActionCreator,
+  namespaceActionDispatcher,
+  ActionWithPayload,
+} from 'rxbeach';
+import { filterNamespace } from 'rxbeach/operators';
+import { AnyAction, actionWithPayload } from 'rxbeach/internal';
+
+const sumOp = reduce(
+  (a, b) => a + ((b as ActionWithPayload<number>).payload || 0),
+  0
+);
+
+export default function namespaceExamples() {
+  describe('namespaces', function() {
+    const testAction = createActionCreator<number>('[test] primitive action');
+    const namespaceA = Symbol('A');
+    const namespaceB = Symbol('B');
+
+    it('can namespace the action creators', async function() {
+      const testActionA = namespaceActionCreator(namespaceA, testAction);
+      const testActionB = namespaceActionCreator(namespaceB, testAction);
+
+      const action$ = of(testActionA(1), testActionB(2));
+
+      const a = await action$.pipe(filterNamespace(namespaceA)).toPromise();
+      const b = await action$.pipe(filterNamespace(namespaceB)).toPromise();
+      const sum = await action$.pipe(sumOp).toPromise();
+
+      deepEqual(a, actionWithPayload(testAction.type, 1, namespaceA));
+      deepEqual(b, actionWithPayload(testAction.type, 2, namespaceB));
+      equal(sum, 3);
+    });
+
+    it('can namespace dispatchAction', async function() {
+      const action$ = new Subject<AnyAction>();
+      const dispatchAction = action$.next.bind(action$);
+
+      const dispatchA = namespaceActionDispatcher(namespaceA, dispatchAction);
+      const dispatchB = namespaceActionDispatcher(namespaceB, dispatchAction);
+
+      const a_p = action$.pipe(filterNamespace(namespaceA)).toPromise();
+      const b_p = action$.pipe(filterNamespace(namespaceB)).toPromise();
+      const sum_p = action$.pipe(sumOp).toPromise();
+
+      dispatchA(testAction(1));
+      dispatchB(testAction(2));
+      action$.complete();
+
+      const [a, b, sum] = await Promise.all([a_p, b_p, sum_p]);
+
+      deepEqual(a, actionWithPayload(testAction.type, 1, namespaceA));
+      deepEqual(b, actionWithPayload(testAction.type, 2, namespaceB));
+      equal(sum, 3);
+    });
+  });
+}

package.json

@@ -6,7 +6,7 @@
   "private": true,
   "license": "MIT",
   "scripts": {
-    "test": "ts-mocha --paths -p tsconfig.json src/**/*.tests.ts examples/**/*.tests.ts",
+    "test": "ts-mocha --paths -p tsconfig.json src/*.tests.ts src/**/*.tests.ts examples/**/*.tests.ts",
     "build": "tsc -p tsconfig.json",
     "lint": "eslint --ext .ts src examples"
   },

src/createActionCreator.ts

@@ -25,9 +25,7 @@ export function createActionCreator(type: string): UnknownActionCreator {
   const action = (payload?: any) => ({
     type,
     payload,
-    meta: {
-      qualifiers: [],
-    },
+    meta: {},
   });
   action.type = type;
 

src/index.ts

@@ -16,3 +16,5 @@ export {
 } from './types/helpers';
 
 export { createActionCreator } from './createActionCreator';
+
+export { namespaceActionCreator, namespaceActionDispatcher } from './namespace';

src/internal/testUtils.ts

@@ -2,17 +2,17 @@ import { ActionWithPayload, ActionWithoutPayload } from 'types/Action';
 
 export const actionWithoutPayload = (
   type: string,
-  qualifiers: string[] = []
+  namespace?: symbol
 ): ActionWithoutPayload => ({
-  meta: { qualifiers },
+  meta: { namespace },
   type,
 });
 
 export const actionWithPayload = <P>(
   type: string,
   payload: P,
-  qualifiers: string[] = []
+  namespace?: symbol
 ): ActionWithPayload<P> => ({
-  ...actionWithoutPayload(type, qualifiers),
+  ...actionWithoutPayload(type, namespace),
   payload,
 });

src/namespace.tests.ts

@@ -0,0 +1,55 @@
+import { deepEqual } from 'assert';
+import {
+  namespaceActionCreator,
+  ActionDispatcher,
+  namespaceActionDispatcher,
+} from 'rxbeach';
+import {
+  actionWithPayload,
+  AnyAction,
+  actionWithoutPayload,
+} from 'rxbeach/internal';
+
+describe('namespace', function() {
+  describe('namespaceActionCreator', function() {
+    it('Should create actions with namespace', function() {
+      const type = 'action type';
+      const namespace = Symbol('new namespace');
+      const actionCreator = (payload: number) =>
+        actionWithPayload(type, payload, Symbol('old namespace'));
+      actionCreator.type = type;
+
+      const namespacedActionCreator = namespaceActionCreator(
+        namespace,
+        actionCreator
+      );
+
+      const action = namespacedActionCreator(12);
+
+      deepEqual(action, actionWithPayload(type, 12, namespace));
+    });
+  });
+
+  describe('namespaceActionDispatcher', function() {
+    it('Should invoke the parent dispatcher with namespaced actions', function() {
+      let dispatchedAction: AnyAction | undefined;
+      const parentDispatcher: ActionDispatcher = action =>
+        (dispatchedAction = action);
+
+      const namespace = Symbol('new namespace');
+      const childDispatcher = namespaceActionDispatcher(
+        namespace,
+        parentDispatcher
+      );
+
+      const action = actionWithoutPayload('action', Symbol('old namespace'));
+
+      childDispatcher(action);
+
+      deepEqual(dispatchedAction, {
+        payload: undefined,
+        ...actionWithoutPayload(action.type, namespace),
+      });
+    });
+  });
+});

src/namespace.ts

@@ -0,0 +1,69 @@
+import { ActionCreator, ActionDispatcher } from 'rxbeach';
+import { UnknownAction } from 'rxbeach/internal';
+
+/**
+ * Create a new namespace
+ *
+ * @param description A description of this namespace, does not need to be
+ *                    unique per instance. Usually the name of what will create
+ *                    instances of namespaces
+ */
+export const createNamespace = (description: string) => Symbol(description);
+
+const _namespaceAction = (namespace: symbol, action: UnknownAction) => ({
+  type: action.type,
+  payload: action.payload,
+  meta: {
+    ...action.meta,
+    namespace,
+  },
+});
+
+/**
+ * Decorate an action creator so the created actions have the given namespace
+ *
+ * The given namespace will replace existing namespaces on the action objects.
+ *
+ * In contrast to `namespaceActionDispatcher`, the function returned by this
+ * function creates an action object instead of dispatching it.
+ *
+ * @see namespaceActionDispatcher
+ * @param namespace The namespace to set for the created actions
+ * @param actionCreator The action creator to decorate
+ * @returns An action creator that creates actions using the passed action
+ *          creator, and sets the given namespace
+ */
+export const namespaceActionCreator = <Payload>(
+  namespace: symbol,
+  actionCreator: ActionCreator<Payload>
+): ActionCreator<Payload> => {
+  const creator = (payload?: any) =>
+    _namespaceAction(namespace, actionCreator(payload));
+  creator.type = actionCreator.type;
+
+  return creator as ActionCreator<Payload>;
+};
+
+/**
+ * Decorate an action dispatcher so it dispatches namespaced actions
+ *
+ * The given namespace is set as the namespace for each action dispatched with
+ * this function, before the action is dispatched with the action dispatcher
+ * from the arguments.
+ *
+ * In contrast to `namespaceActionCreator`, the function returned by this
+ * function dispatches the action, instead of creating it.
+ *
+ * @see namespaceActionCreator
+ * @param parentDispatcher The dispatcher the returned action dispatcher will
+ *                         dispatch to
+ * @param namespace The namespace that will be set for each action before they
+ *                  are passed on to the parent dispatcher
+ * @returns An action dispatcher that sets the namespace before passing the
+ *          actions to the parent dispatcher
+ */
+export const namespaceActionDispatcher = (
+  namespace: symbol,
+  parentDispatcher: ActionDispatcher
+): ActionDispatcher => action =>
+  parentDispatcher(_namespaceAction(namespace, action));

src/operators/index.ts

@@ -1 +1 @@
-export { ofType, extractPayload } from './operators';
+export { ofType, extractPayload, filterNamespace } from './operators';

src/operators/operators.ts

@@ -1,6 +1,6 @@
 import { OperatorFunction, MonoTypeOperatorFunction } from 'rxjs';
 import { map, filter } from 'rxjs/operators';
-import { ActionWithPayload } from 'rxbeach';
+import { ActionWithPayload, Action } from 'rxbeach';
 import { AnyAction } from 'rxbeach/internal';
 
 //// Routines ////
@@ -39,3 +39,13 @@ export const extractPayload = <Payload>(): OperatorFunction<
   ActionWithPayload<Payload>,
   Payload
 > => map(action => action.payload);
+
+/**
+ * Stream operator that filters for actions with the correct namespace
+ *
+ * @param namespace The namespace to filter for
+ */
+export const filterNamespace = (
+  targetNamespace: symbol
+): MonoTypeOperatorFunction<Action<any>> =>
+  filter(({ meta: { namespace } }) => namespace === targetNamespace);

src/types/Action.ts

@@ -1,7 +1,7 @@
 import { VoidPayload } from 'rxbeach/internal';
 
 type Meta = {
-  qualifiers: string[];
+  namespace?: symbol;
 };
 
 export type ActionWithoutPayload = {