feat(command-flow): add package

Author: Char2sGu

package-lock.json

@@ -0,0 +1,25 @@
+# CommandFlow
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 17.3.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project command-flow` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project command-flow`.
+
+> Note: Don't forget to add `--project command-flow` or else it will be added to the default project in your `angular.json` file.
+
+## Build
+
+Run `ng build command-flow` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build command-flow`, go to the dist folder `cd dist/command-flow` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test command-flow` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

packages/command-flow/README.md

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/command-flow",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  }
+}

packages/command-flow/ng-package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@angularity/command-flow",
+  "version": "0.1.0",
+  "peerDependencies": {
+    "@angular/common": "17.x.x",
+    "@angular/core": "17.x.x",
+    "@angularity/core": "*",
+    "rxjs": "7.x.x"
+  },
+  "dependencies": {
+    "ts-pattern": "^5.1.1",
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false
+}

packages/command-flow/package.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "name": "command-flow",
+  "projectType": "library",
+  "sourceRoot": "packages/command-flow/src",
+  "prefix": "agl",
+  "targets": {
+    "build": {
+      "executor": "@angular-devkit/build-angular:ng-packagr",
+      "options": {
+        "project": "packages/command-flow/ng-package.json"
+      },
+      "configurations": {
+        "production": {
+          "tsConfig": "packages/command-flow/tsconfig.lib.prod.json"
+        },
+        "development": {
+          "tsConfig": "packages/command-flow/tsconfig.lib.json"
+        }
+      },
+      "defaultConfiguration": "production"
+    },
+    "test": {
+      "executor": "@angular-devkit/build-angular:karma",
+      "options": {
+        "tsConfig": "packages/command-flow/tsconfig.spec.json",
+        "polyfills": ["zone.js", "zone.js/testing"]
+      }
+    }
+  }
+}

packages/command-flow/project.json

@@ -0,0 +1,44 @@
+import { forwardRef, Injectable } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+
+import { Command, CommandEvent } from './core';
+
+@Injectable({
+  providedIn: 'root',
+  useExisting: forwardRef(() => SubjectBasedCommandBus),
+})
+export abstract class CommandBus extends Observable<Command> {
+  abstract dispatch(command: Command): void;
+}
+
+@Injectable({
+  providedIn: 'root',
+  useExisting: forwardRef(() => SubjectBasedCommandEventBus),
+})
+export abstract class CommandEventBus extends Observable<CommandEvent> {
+  abstract publish(event: CommandEvent): void;
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class SubjectBasedCommandBus
+  extends Subject<Command>
+  implements CommandBus
+{
+  dispatch(command: Command): void {
+    this.next(command);
+  }
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class SubjectBasedCommandEventBus
+  extends Subject<CommandEvent>
+  implements CommandEventBus
+{
+  publish(event: CommandEvent): void {
+    this.next(event);
+  }
+}

packages/command-flow/src/lib/core/buses.ts

@@ -0,0 +1,25 @@
+export const COMMAND_META = Symbol('COMMAND_META');
+
+export interface CommandMetadata {}
+
+export abstract class Command {
+  abstract [COMMAND_META]: CommandMetadata;
+  private constructor() {}
+  static [Symbol.hasInstance](input: object): boolean {
+    return input && COMMAND_META in input;
+  }
+}
+
+export const COMMAND_EVENT_META = Symbol('COMMAND_EVENT_META');
+
+export interface CommandEventMetadata<C extends Command = Command> {
+  source: C;
+}
+
+export abstract class CommandEvent<C extends Command = Command> {
+  abstract [COMMAND_EVENT_META]: CommandEventMetadata<C>;
+  private constructor() {}
+  static [Symbol.hasInstance](input: object): boolean {
+    return input && COMMAND_EVENT_META in input;
+  }
+}

packages/command-flow/src/lib/core/core.ts

@@ -0,0 +1,27 @@
+import { inject, Type } from '@angular/core';
+import { filter, Observable } from 'rxjs';
+
+import { CommandBus, CommandEventBus } from './buses';
+import { Command, COMMAND_EVENT_META as META, CommandEvent } from './core';
+import { CommandFlowScheduler } from './scheduler';
+
+export const useCommand =
+  <T extends Type<Command>>(
+    type: T,
+    [scheduler, commands$, events$] = [
+      inject(CommandFlowScheduler),
+      inject(CommandBus),
+      inject(CommandEventBus),
+    ],
+  ) =>
+  (
+    ...args: ConstructorParameters<T>
+  ): Observable<CommandEvent<InstanceType<T>>> => {
+    const command = new type(...args);
+    scheduler.next(() => commands$.dispatch(command));
+    return events$.pipe(
+      filter(
+        (e): e is CommandEvent<InstanceType<T>> => e[META].source === command,
+      ),
+    );
+  };

packages/command-flow/src/lib/core/facade.ts

@@ -0,0 +1,52 @@
+import { inject, Type } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Observable, tap } from 'rxjs';
+
+import { pickType } from '../utilities/reactive-x';
+import { CommandBus, CommandEventBus } from './buses';
+import { Command, CommandEvent } from './core';
+import { CommandFlowScheduler } from './scheduler';
+
+export interface CommandHandler<C extends Command> {
+  (stream: Observable<C>): Observable<void | CommandEvent<C>>;
+}
+
+export interface CommandEventHandler<E extends CommandEvent> {
+  (stream: Observable<E>): Observable<void | Command>;
+}
+
+export function registerCommandHandler<Types extends Type<Command>[]>(
+  types: Types,
+  handler: CommandHandler<InstanceType<Types[number]>>,
+): void {
+  const commands$ = inject(CommandBus);
+  const events$ = inject(CommandEventBus);
+  const scheduler = inject(CommandFlowScheduler);
+  commands$
+    .pipe(
+      takeUntilDestroyed(),
+      pickType(...types),
+      handler,
+      pickType(CommandEvent),
+      tap((event) => scheduler.next(() => events$.publish(event))),
+    )
+    .subscribe();
+}
+
+export function registerCommandEventHandler<Types extends Type<CommandEvent>[]>(
+  types: Types,
+  handler: CommandEventHandler<InstanceType<Types[number]>>,
+): void {
+  const events$ = inject(CommandEventBus);
+  const commands$ = inject(CommandBus);
+  const scheduler = inject(CommandFlowScheduler);
+  events$
+    .pipe(
+      takeUntilDestroyed(),
+      pickType(...types),
+      handler,
+      pickType(Command),
+      tap((command) => scheduler.next(() => commands$.dispatch(command))),
+    )
+    .subscribe();
+}

packages/command-flow/src/lib/core/handlers.ts

@@ -0,0 +1,4 @@
+export * from './buses';
+export * from './core';
+export * from './facade';
+export * from './handlers';