@ingenioz-it/caits 0.5.1 → 0.6.0

package/src/messaging/FrontendContextMap.ts

@@ -0,0 +1,33 @@
+type EventClass<E> = abstract new (...args: never[]) => E;
+
+/**
+ * One line of the context map of a frontend context: an event of the context shared that it hears, which becomes events of the context,
+ * or an event of the context that it shares, which becomes events of the context shared.
+ */
+export type Line = { readonly shares: boolean; readonly event: EventClass<object>; readonly events: (event: never) => object[] };
+
+/**
+ * A line that hears the context shared, in the context map of a frontend context (its context-map.ts): when this event of shared comes
+ * on the shared bus, the context publishes these events of its own on its own bus, and its store reads them. A context map names only
+ * its own context and the context shared: two contexts never name each other.
+ */
+export function when<E extends object>(event: EventClass<E>, events: (event: E) => object[]): Line {
+  return { shares: false, event, events };
+}
+
+/**
+ * A line that tells the other contexts: when a view, a component or a handler of the context publishes this event of its own on its
+ * bus, the context publishes these events of shared on the shared bus, and the context map of each context that hears them turns them
+ * into events of its own. The event of the context holds what the events of shared need.
+ */
+export function share<E extends object>(event: EventClass<E>, events: (event: E) => object[]): Line {
+  return { shares: true, event, events };
+}
+
+/**
+ * The events that a map gives for an event, line by line, none when no line reads it: for an event of shared that it hears, events of
+ * the context; for an event of the context that it shares, events of shared.
+ */
+export function eventsFor(map: readonly Line[], event: object): object[] {
+  return map.filter(line => event instanceof line.event).flatMap(line => line.events(event as never));
+}

package/src/testing/backend/applications.ts

@@ -14,7 +14,7 @@ const testBindings: Record<string, readonly Binding[]> = Object.fromEntries(
 
 type EventType<E extends DomainEvent> = abstract new (...args: never[]) => E;
 
-/** The whole backend, built from the bindings of its contexts with their test.di.ts over them, and predictable ids. For the tests of the context map. */
+/** The whole backend, built from the bindings of its contexts with their test.di.ts over them, and predictable ids. For the tests of the context maps. */
 export function createTestBackendApplication() {
   const reportedErrors: unknown[] = [];
   const published: Published[] = [];
@@ -29,7 +29,7 @@ export function createTestBackendApplication() {
   return {
     ...backend,
     reportedErrors,
-    /** Every event the contexts published, in its envelope, in the order they were published. */
+    /** Every event of shared that the context maps shared, in its envelope, in the order they were published. */
     published,
     publishedNames: () => published.map(({ event }) => event.constructor.name),
     publishedOf: <E extends DomainEvent>(type: EventType<E>): E[] => published.flatMap(({ event }) => event instanceof type ? [event] : [])
@@ -37,13 +37,14 @@ export function createTestBackendApplication() {
 }
 
 /**
- * Every context, built from its di.ts with its test.di.ts over it, but alone: no event reaches another context. A test sends input DTOs
- * and reads the events the handlers published.
+ * Every context, built from its di.ts with its test.di.ts over it, but alone: no context map hears or shares an event. A test sends
+ * input DTOs and reads the events of their context that the handlers published.
  */
 export function createTestApplication() {
   const published: DomainEvent[] = [];
-  const backend = createBackend({ ...discovered, map: [] }, { replace: testBindings, reportError: () => undefined });
-  backend.subscribe(({ event }) => { published.push(event); });
+  const alone = Object.fromEntries(Object.entries(discovered.contexts).map(([name, context]) => [name, { ...context, map: [] }]));
+  const backend = createBackend({ ...discovered, contexts: alone }, { replace: testBindings, reportError: () => undefined });
+  backend.subscribeToContexts(event => { published.push(event); });
 
   return {
     /** Sends an input DTO to the message bus of the context that handles it. */

package/src/testing/backend/context-map.ts

@@ -1,7 +1,10 @@
 import { test as base } from "vitest";
 import { createTestBackendApplication, type TestBackendApplication } from "./applications.js";
 
-/** Everything a test of the context map imports. `test` checks the Input DTOs that the `ContextMap` gives for an Event. */
+/**
+ * Everything a test of the context map imports. `test` checks what the `ContextMap` gives: the input DTOs for an event of shared
+ * (`inputsFor`), the events of shared for an event of the context (`eventsFor`).
+ */
 export { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
 export { ContextMap } from "../../messaging/ContextMap.js";
 export type { TestBackendApplication } from "./applications.js";

package/src/testing/frontend/context-map.ts

@@ -0,0 +1,6 @@
+/**
+ * Everything a test of the context map of a frontend context imports: `eventsFor` gives the events of the context that an event of the
+ * context shared gives, and the events of shared that an event of the context gives.
+ */
+export { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+export { eventsFor } from "../../messaging/FrontendContextMap.js";

package/src/testing/frontend/frontends.ts

@@ -1,23 +1,30 @@
 import { FrontendEventBus } from "../../messaging/FrontendEventBus.js";
 import type { Input } from "../../messaging/Input.js";
 import { createStore, type StoreDefinition } from "../../state/createStore.js";
-import type { Frontend } from "../../state/request.js";
+import type { EventPublisher } from "../../messaging/EventPublisher.js";
 import { discoveredFrontends } from "../../di/discoveredFrontends.js";
 import { frontendsOn, type Frontends } from "../../di/frontend.js";
 
-type StateOf<F> = F extends Frontend<infer S, unknown> ? S : never;
-type EventOf<F> = F extends Frontend<unknown, infer E> ? E : never;
+type EventOf<F> = F extends { events: EventPublisher<infer E> } ? E : never;
+type StoreOf<F> = F extends { store: infer S } ? S : undefined;
+
+/** The presentation of a context in a test: its frontend, the DTOs that its store sent, and the events that it published. */
+export type TestPresentation<F> = { events: EventPublisher<EventOf<F>>; store: StoreOf<F>; sent: Input<unknown>[]; published: EventOf<F>[] };
 
 /**
- * The presentation of a context, as its views get it: its EventPublisher and its store. The message bus of the store is a Fake: it
- * records the DTOs it receives, and answers nothing. A test publishes the events of the handlers itself.
+ * The presentation of a context, as its views and its components get it: its EventPublisher and its store (none, for a context
+ * without a store). The message bus of the store is a Fake: it records the DTOs it receives in `sent`, and answers nothing. A test
+ * publishes the events of the handlers itself. `published` records every event of the bus, in their order: those that the views and
+ * the components publish. The context map is left aside: its own test reads what it shares.
  */
-export function testPresentation<Name extends keyof Frontends>(name: Name): Frontend<StateOf<Frontends[Name]>, EventOf<Frontends[Name]>> & { sent: Input<unknown>[] } {
+export function testPresentation<Name extends keyof Frontends>(name: Name): TestPresentation<Frontends[Name]> {
   const events = new FrontendEventBus<EventOf<Frontends[Name]>>();
   const sent: Input<unknown>[] = [];
-  const definition = discoveredFrontends[name].store as StoreDefinition<StateOf<Frontends[Name]>, EventOf<Frontends[Name]>>;
-  const store = createStore(definition, { events, bus: { send: <Output>(input: Input<Output>) => { sent.push(input); return Promise.resolve(undefined as Output); } } });
-  return { events, store, sent };
+  const published: EventOf<Frontends[Name]>[] = [];
+  events.subscribe(event => { published.push(event); });
+  const definition = discoveredFrontends[name].store as StoreDefinition<unknown, EventOf<Frontends[Name]>> | undefined;
+  const store = definition && createStore(definition, { events, bus: { send: <Output>(input: Input<Output>) => { sent.push(input); return Promise.resolve(undefined as Output); } } });
+  return { events, store, sent, published } as unknown as TestPresentation<Frontends[Name]>;
 }
 
 /** A $global as Marko gives it to the views: the address of the page, and frontends already built. */

package/src/virtual-modules.d.ts

@@ -7,7 +7,7 @@ declare module "virtual:kernel/backend" {
   export const dtos: Modules;
   export const handlers: Modules;
   export const controllers: Modules;
-  export const map: Record<string, Translation[]>;
+  export const maps: Record<string, Translation[]>;
 }
 
 declare module "virtual:kernel/backend-test" {
@@ -17,12 +17,14 @@ declare module "virtual:kernel/backend-test" {
 
 declare module "virtual:kernel/frontend" {
   import type { Binding } from "@ingenioz-it/caits/di/Container";
+  import type { Line } from "@ingenioz-it/caits/messaging/FrontendContextMap";
   import type { StoreDefinition } from "@ingenioz-it/caits/state/createStore";
   type Modules = Record<string, Record<string, unknown>>;
   export const bindings: Record<string, readonly Binding[]>;
   export const dtos: Modules;
   export const handlers: Modules;
   export const stores: Record<string, StoreDefinition<unknown, unknown>>;
+  export const maps: Record<string, readonly Line[]>;
 }
 
 declare module "virtual:kernel/frontend-test" {

package/src/vite.js

@@ -58,17 +58,18 @@ function dependencies(source) {
 const CONTEXT_MODULES = {
   "virtual:kernel/backend": [
     ["bindings", "backend/*/di.ts", true],
-    ["dtos", "backend/*/application/*/*/*.dto.ts"],
-    ["handlers", "backend/*/application/*/*/*.handler.ts"],
-    ["controllers", "backend/*/presentation/*/*.controller.ts"],
-    ["map", "backend/context-map.ts", true]
+    ["dtos", "backend/*/{command,query}/*/*.dto.ts"],
+    ["handlers", "backend/*/{command,query}/*/*.handler.ts"],
+    ["controllers", "backend/*/{command,query}/*/*.controller.ts"],
+    ["maps", "backend/*/context-map.ts", true]
   ],
   "virtual:kernel/backend-test": [["bindings", "backend/*/test.di.ts", true]],
   "virtual:kernel/frontend": [
     ["bindings", "frontend/*/di.ts", true],
-    ["dtos", "frontend/*/application/*/*/*.dto.ts"],
-    ["handlers", "frontend/*/application/*/*/*.handler.ts"],
-    ["stores", "frontend/*/presentation/store/*Store.ts", true]
+    ["dtos", "frontend/*/{command,query}/*/*.dto.ts"],
+    ["handlers", "frontend/*/{command,query}/*/*.handler.ts"],
+    ["stores", "frontend/*/presentation/store/*Store.ts", true],
+    ["maps", "frontend/*/context-map.ts", true]
   ],
   "virtual:kernel/frontend-test": [["bindings", "frontend/*/test.di.ts", true]]
 };
@@ -86,9 +87,9 @@ function contexts(source) {
   /** @type {(pattern: string, onlyDefault?: boolean) => string} */
   const glob = (pattern, onlyDefault = false) =>
     `import.meta.glob(${JSON.stringify(`${source}/${pattern}`)}, { eager: true${onlyDefault ? `, import: "default"` : ""} })`;
-  /** A pattern as a regular expression: `*` is a part of a name, without "/". */
-  const matcherOf = (/** @type {string} */ pattern) =>
-    new RegExp(`^${`${source}/${pattern}`.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", "[^/]*")}$`);
+  /** A pattern as a regular expression: `*` is a part of a name, without "/", and `{command,query}` one of these names. */
+  const matcherOf = (/** @type {string} */ pattern) => new RegExp(`^${`${source}/${pattern}`.replace(/[.+?^$()|[\]\\]/g, "\\$&").replaceAll("*", "[^/]*")
+    .replace(/\{([^}]*)\}/g, (/** @type {string} */ _, /** @type {string} */ names) => `(?:${names.split(",").join("|")})`)}$`);
   const modules = Object.entries(CONTEXT_MODULES).map(([id, exports]) => ({
     id,
     code: exports.map(([name, pattern, onlyDefault]) => `export const ${name} = ${glob(pattern, onlyDefault)};`).join("\n"),
@@ -102,9 +103,15 @@ function contexts(source) {
       // Vite processes the package as the code of the project, also when it is installed: it holds TypeScript and imports these modules.
       ssr: { noExternal: [KERNEL] },
       optimizeDeps: { exclude: [KERNEL] },
-      // The shortcut #shared leads to the backend context shared from every file (the tsconfig.json of the project says it to TypeScript).
-      // Vite reads an alias before the "imports" of the package.json of a context (#context), which cannot lead out of the context.
-      resolve: { alias: [{ find: /^#shared\//, replacement: `${source}/backend/shared/` }] }
+      // The shortcut #shared leads to the backend context shared from every file, and #frontend-shared to the frontend context shared
+      // (the tsconfig.json of the project says it to TypeScript). Vite reads an alias before the "imports" of the package.json of a
+      // context (#context), which cannot lead out of the context.
+      resolve: {
+        alias: [
+          { find: /^#shared\//, replacement: `${source}/backend/shared/` },
+          { find: /^#frontend-shared\//, replacement: `${source}/frontend/shared/` }
+        ]
+      }
     }),
     configResolved: config => { root = config.root; },
     configureServer: server => {