fix: remove System

libs/calculator-artifacts/src/__tests__/calculator.spec.ts

@@ -8,14 +8,13 @@ import {
 } from "@rotorsoft/eventually";
 import { Chance } from "chance";
 import { Calculator } from "../calculator.aggregate";
-import { Forget } from "../forget.system";
+import { CalculatorCommands } from "../calculator.schemas";
 import { ExternalPayload, PressKeyAdapter } from "../presskey.adapter";
 import { pressKey } from "./messages";
-import { CalculatorCommands } from "../calculator.schemas";
 
 // app setup
 const chance = new Chance();
-app().with(Forget).with(Calculator).with(PressKeyAdapter).build();
+app().with(Calculator).with(PressKeyAdapter).build();
 
 describe("Calculator", () => {
   beforeAll(async () => {

libs/eventually-aws/src/lambda/command.ts

@@ -33,7 +33,7 @@ export const command = async ({
         system,
         parsedPath: `/${system}/${stream}/${command}`
       });
-    if (!(md.type === "aggregate" || md.type === "system"))
+    if (!(md.type === "aggregate"))
       return BadRequest("Invalid system", {
         system,
         type: md.type,

libs/eventually-openapi/src/HttpClient.ts

@@ -66,11 +66,7 @@ export const HttpClient = (
       const headers = {} as Record<string, string>;
       target.expectedVersion &&
         (headers["If-Match"] = target.expectedVersion.toString());
-      const path = httpPostPath(
-        factory.name,
-        "reduce" in factory("") ? "aggregate" : "system",
-        name as string
-      );
+      const path = httpPostPath(factory.name, "aggregate", name as string);
       const { data } = await axios.default.post(
         url(path.replace(":id", target?.stream || "")),
         payload,

libs/eventually-openapi/src/home/artifacts.ts

@@ -30,8 +30,6 @@ const _color = (type: ArtifactType): string => {
       return "primary";
     case "projector":
       return "success";
-    case "system":
-      return "secondary";
     default:
       return "danger";
   }
@@ -47,7 +45,7 @@ export const artifacts = (): string =>
         <p class="m-0 fw-lighter fst-italic" style="font-size:75%">${
           factory("").description
         }</p>
-        ${_inputs(type === "aggregate" || type === "system", inputs)}
+        ${_inputs(type === "aggregate", inputs)}
         <hr />
         ${_outputs(outputs)}
         </div></div></div>`

libs/eventually-openapi/src/home/esml.ts

@@ -1,6 +1,6 @@
 import { app, camelize } from "@rotorsoft/eventually";
-import { config } from "..";
 import { z } from "zod";
+import { config } from "..";
 
 const ZOD2TYPE: { [K in z.ZodFirstPartyTypeKind]?: string } = {
   [z.ZodFirstPartyTypeKind.ZodString]: "string",
@@ -93,12 +93,12 @@ export const esml = (): Record<string, any> => {
   [...app().artifacts.values()]
     .filter((a) => a.type !== "command-adapter")
     .forEach((a) => {
-      const sys = a.type === "aggregate" || a.type === "system";
+      const agg = a.type === "aggregate";
       const art = (model[a.factory.name] = {
         type: a.type
       } as Record<string, any>);
       if (a.inputs.length) art.handles = a.inputs.map((i) => i.name);
-      if (a.outputs.length) art[sys ? "emits" : "invokes"] = a.outputs;
+      if (a.outputs.length) art[agg ? "emits" : "invokes"] = a.outputs;
       if (a.schema) art.schema = toSchema(a.schema, model);
     });
 

libs/eventually-openapi/src/utils/oas.ts

@@ -111,10 +111,10 @@ const toResponse = (
               : {}
           }
         : ref
-        ? {
-            $ref: `#/components/schemas/${ref}`
-          }
-        : {}
+          ? {
+              $ref: `#/components/schemas/${ref}`
+            }
+          : {}
     }
   },
   headers
@@ -312,7 +312,7 @@ const getArtifactPaths = (
           }
         };
       }
-      if (type === "aggregate" || type === "system") {
+      if (type === "aggregate") {
         endpoints.forEach((message) => {
           const path = httpPostPath(factory.name, type, message);
           paths[path.replace("/:id/", "/{id}/")] = {

libs/eventually-openapi/src/utils/utils.ts

@@ -11,8 +11,6 @@ export const httpPostPath = (
   switch (type) {
     case "aggregate":
       return "/".concat(decamelize(name), "/:id/", decamelize(message));
-    case "system":
-      return "/".concat(decamelize(name), "/", decamelize(message));
     default:
       return "/".concat(decamelize(name));
   }

libs/eventually/src/builder.ts

@@ -165,7 +165,7 @@ export abstract class Builder extends EventEmitter implements Disposable {
             });
           });
           return {
-            type: reducible ? "aggregate" : "system",
+            type: "aggregate",
             factory,
             schema,
             inputs: inputs.map((name) => ({ name, scope })),

libs/eventually/src/handlers/command.ts

@@ -1,9 +1,9 @@
 import { randomUUID } from "crypto";
 import { app, log } from "../ports";
 import {
+  AggregateFactory,
   InvariantError,
   RegistrationError,
-  type CommandHandlerFactory,
   type CommittedEventMetadata,
   type Message,
   type Messages,
@@ -35,7 +35,7 @@ export default async function command<
   if (!msg?.handlers.length) throw new RegistrationError(command);
 
   const factory = app().artifacts.get(msg.handlers[0])
-    ?.factory as unknown as CommandHandlerFactory<S, C, E>;
+    ?.factory as unknown as AggregateFactory<S, C, E>;
   if (!factory) throw new RegistrationError(command);
 
   log().blue().trace(`\n>>> ${factory.name}`, command, metadata);

libs/eventually/src/port.ts

@@ -27,7 +27,7 @@ const disposers: Disposer[] = [];
 const disposeAndExit = async (code: ExitCode = "UNIT_TEST"): Promise<void> => {
   await Promise.all(disposers.map((disposer) => disposer()));
   await Promise.all(
-    [...adapters].map(async ([key, adapter]) => {
+    [...adapters].reverse().map(async ([key, adapter]) => {
       log(`♻️ ${adapter.name || key}`);
       await adapter.dispose();
     })

libs/eventually/src/types/artifacts.ts

@@ -12,7 +12,6 @@ import type { Projection } from "./projection";
 
 /** All artifact types */
 export type ArtifactType =
-  | "system"
   | "aggregate"
   | "policy"
   | "process-manager"
@@ -34,16 +33,6 @@ export type Schemas<M extends Messages> = { [K in keyof M]: ZodType<M[K]> };
 /** Schema defines state validation */
 export type Schema<S extends State> = ZodType<S>;
 
-/**
- * System schemas for
- * - `schemas.commands` input validation
- * - `schemas.events` output validation
- */
-export type SystemSchemas<C extends Messages, E extends Messages> = {
-  commands: Schemas<C>;
-  events: Schemas<E>;
-};
-
 /**
  * Aggregate schemas for
  * - `schemas.state` state documentation
@@ -125,19 +114,6 @@ export type Reducible<
   reducer?: StateReducer<S>;
 };
 
-/**
- * Systems handle commands and produce a stream of committed events
- * - `schemas` for message validation and documentation
- * - `on` command handlers
- */
-export type System<
-  C extends Messages = Messages,
-  E extends Messages = Messages
-> = Streamable & {
-  schemas: SystemSchemas<C, E>;
-  on: { [K in keyof C]: CommandHandler<State, C, E, K> };
-};
-
 /**
  * Aggregates handle commands and produce committed events while holding an internal reducible state.
  * Aggregates enforce a consistency boundaries around business models.
@@ -230,7 +206,7 @@ export type CommandHandlingArtifact<
   S extends State = State,
   C extends Messages = Messages,
   E extends Messages = Messages
-> = Aggregate<S, C, E> | System<C, E>;
+> = Aggregate<S, C, E>;
 
 /** All event handling artifacts */
 export type EventHandlingArtifact<
@@ -258,45 +234,31 @@ export type Infer<T> = T extends ZodRawShape
       [K in keyof T]: z.infer<T[K]>;
     }
   : T extends ZodTypeAny
-  ? z.infer<T>
-  : never;
-
-/** Helper to infer system types from schemas */
-export type InferSystem<Z> = Z extends SystemSchemas<infer C, infer E>
-  ? System<C, E>
-  : never;
+    ? z.infer<T>
+    : never;
 
 /** Helper to infer aggregate types from schemas */
-export type InferAggregate<Z> = Z extends AggregateSchemas<
-  infer S,
-  infer C,
-  infer E
->
-  ? Aggregate<S, C, E>
-  : never;
+export type InferAggregate<Z> =
+  Z extends AggregateSchemas<infer S, infer C, infer E>
+    ? Aggregate<S, C, E>
+    : never;
 
 /** Helper to infer policy types from schemas */
-export type InferPolicy<Z> = Z extends PolicySchemas<infer C, infer E>
-  ? Policy<C, E>
-  : never;
+export type InferPolicy<Z> =
+  Z extends PolicySchemas<infer C, infer E> ? Policy<C, E> : never;
 
 /** Helper to infer process manager types from schemas */
-export type InferProcessManager<
-  Z,
-  O extends Messages
-> = Z extends ProcessManagerSchemas<infer S, infer C, infer E>
-  ? ProcessManager<S, C, E, O>
-  : never;
+export type InferProcessManager<Z, O extends Messages> =
+  Z extends ProcessManagerSchemas<infer S, infer C, infer E>
+    ? ProcessManager<S, C, E, O>
+    : never;
 
 /** Helper to infer command adapter types from schemas */
-export type InferCommandAdapter<Z> = Z extends CommandAdapterSchemas<
-  infer S,
-  infer C
->
-  ? CommandAdapter<S, C>
-  : never;
+export type InferCommandAdapter<Z> =
+  Z extends CommandAdapterSchemas<infer S, infer C>
+    ? CommandAdapter<S, C>
+    : never;
 
 /** Helper to infer projector types from schemas */
-export type InferProjector<Z> = Z extends ProjectorSchemas<infer S, infer E>
-  ? Projector<S, E>
-  : never;
+export type InferProjector<Z> =
+  Z extends ProjectorSchemas<infer S, infer E> ? Projector<S, E> : never;