@cratis/event-models 0.278.2 → 0.279.0

package/dist/Cards/cardColors.d.ts

@@ -18,6 +18,8 @@ export declare const eventCardColors: CardColors;
 export declare const commandCardColors: CardColors;
 /** Read model card colors — lime green. */
 export declare const readModelCardColors: CardColors;
+/** Query card colors — indigo, the query a State View specification runs; distinct from every other artifact. */
+export declare const queryCardColors: CardColors;
 /** Projection card colors — pink, the output translator's mapping of private events onto its public event. */
 export declare const projectionCardColors: CardColors;
 /** Capture (change data capture) card colors — teal, the input translator's mapping of incoming events onto private events. */

package/dist/Messages/EventModelMessages.d.ts

@@ -207,6 +207,9 @@ export interface EventModelMessages {
         error: string;
         missingRule: string;
         defineReadModel: string;
+        addQuery: string;
+        addReadModel: string;
+        addResult: string;
         removeItem: string;
         noEvents: string;
         redeliverGivenEvent: string;

package/dist/Model/SliceSpecification.d.ts

@@ -8,6 +8,7 @@ import type { SpecificationReadModel } from './SpecificationReadModel';
 import type { SpecificationRedelivery } from './SpecificationRedelivery';
 import type { SpecificationRunOutcome } from './SpecificationRunOutcome';
 import type { SpecificationThenEvent } from './SpecificationThenEvent';
+import type { SpecificationWhenQuery } from './SpecificationWhenQuery';
 import type { SpecificationWhenEvent } from './SpecificationWhenEvent';
 export interface SliceSpecification {
     id: Guid;
@@ -21,9 +22,12 @@ export interface SliceSpecification {
     whenEvent?: SpecificationWhenEvent;
     whenRedelivered?: SpecificationRedelivery;
     caller?: SpecificationCaller;
+    whenQuery?: SpecificationWhenQuery;
     givenReadModel?: SpecificationReadModel;
+    givenReadModels?: SpecificationReadModel[];
     thenEvents: SpecificationThenEvent[];
     thenReadModel?: SpecificationReadModel;
+    thenReadModels?: SpecificationReadModel[];
     thenNoEvents?: boolean;
     thenErrors: SpecificationError[];
     collapsed: boolean;

package/dist/Model/SpecificationWhenQuery.d.ts

@@ -0,0 +1,7 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface SpecificationWhenQuery {
+    queryItemId: Guid;
+    name: string;
+    arguments: Record<string, unknown>;
+    legacy?: boolean;
+}

package/dist/Model/index.d.ts

@@ -56,6 +56,7 @@ export * from './SpecificationRedelivery';
 export * from './SpecificationRunOutcome';
 export * from './SpecificationThenEvent';
 export * from './SpecificationWhenEvent';
+export * from './SpecificationWhenQuery';
 export * from './StickyNote';
 export * from './StickyNoteColour';
 export * from './TranslationDirection';

package/dist/Specifications/SpecificationAddPicker.d.ts

@@ -11,5 +11,6 @@ export interface SpecificationAddPickerProps<TOption> {
     errors?: readonly SpecificationAddExtra[];
     statements?: readonly SpecificationAddExtra[];
     groups?: readonly SpecificationAddGroup[];
+    color?: string;
 }
-export declare const SpecificationAddPicker: <TOption>({ options, nameOf, onChosen, errors, statements, groups }: SpecificationAddPickerProps<TOption>) => React.JSX.Element;
+export declare const SpecificationAddPicker: <TOption>({ options, nameOf, onChosen, errors, statements, groups, color }: SpecificationAddPickerProps<TOption>) => React.JSX.Element;

package/dist/Specifications/SpecificationEditing.d.ts

@@ -30,5 +30,14 @@ export interface SpecificationEditing {
     onWhenRedeliveryRemoved?: (sliceId: Guid, specificationId: Guid) => void;
     onWhenEventValuesSet?: (sliceId: Guid, specificationId: Guid, eventId: Guid, name: string, values: Record<string, unknown>, eventSourceId?: string) => void;
     onWhenEventRemoved?: (sliceId: Guid, specificationId: Guid) => void;
+    onWhenQuerySet?: (sliceId: Guid, specificationId: Guid, queryItemId: Guid, name: string) => void;
+    onWhenQueryArgumentsSet?: (sliceId: Guid, specificationId: Guid, values: Record<string, unknown>) => void;
+    onWhenQueryRemoved?: (sliceId: Guid, specificationId: Guid) => void;
+    onGivenReadModelAdded?: (sliceId: Guid, specificationId: Guid, itemId: Guid, readModelId: Guid, name: string) => void;
+    onGivenReadModelItemValuesSet?: (sliceId: Guid, specificationId: Guid, itemId: Guid, values: Record<string, unknown>) => void;
+    onGivenReadModelItemRemoved?: (sliceId: Guid, specificationId: Guid, itemId: Guid) => void;
+    onThenResultAdded?: (sliceId: Guid, specificationId: Guid, itemId: Guid, readModelId: Guid, name: string) => void;
+    onThenResultValuesSet?: (sliceId: Guid, specificationId: Guid, itemId: Guid, readModelId: Guid, name: string, values: Record<string, unknown>) => void;
+    onThenResultRemoved?: (sliceId: Guid, specificationId: Guid, itemId: Guid) => void;
     onSpecificationItemOpened?: (item: SpecificationItemToOpen) => void;
 }

package/dist/Specifications/SpecificationItemKind.d.ts

@@ -1,5 +1,6 @@
 export declare enum SpecificationItemKind {
     event = "event",
     command = "command",
-    readModel = "readModel"
+    readModel = "readModel",
+    query = "query"
 }

package/dist/Specifications/ThenSection.d.ts

@@ -1,6 +1,6 @@
 import { type ReactNode } from 'react';
 import { Guid } from '@cratis/fundamentals';
-import type { CommandItem, EventItem, ReadModelItem, SliceSpecification } from '../Model';
+import type { CommandItem, EventItem, QueryItem, ReadModelItem, SliceSpecification } from '../Model';
 import { SliceType } from '../Model';
 import type { SpecificationAddGroup } from './SpecificationAddGroup';
 export interface ThenSectionProps {
@@ -13,6 +13,7 @@ export interface ThenSectionProps {
     renamedEventNames?: Readonly<Record<string, string>>;
     extra?: ReactNode;
     extraGroups?: readonly SpecificationAddGroup[];
+    queries?: readonly QueryItem[];
     onItemsChanged?: (events: number, errors: number) => void;
 }
-export declare const ThenSection: ({ sliceId, sliceType, specification, events, command, readModel, renamedEventNames, extra, extraGroups, onItemsChanged }: ThenSectionProps) => import("react").JSX.Element;
+export declare const ThenSection: ({ sliceId, sliceType, specification, events, command, readModel, renamedEventNames, extra, extraGroups, queries, onItemsChanged }: ThenSectionProps) => import("react").JSX.Element;

package/dist/Specifications/WhenSection.d.ts

@@ -1,5 +1,5 @@
 import { Guid } from '@cratis/fundamentals';
-import type { AutomationTrigger, CommandItem, EventItem, SliceSpecification } from '../Model';
+import type { AutomationTrigger, CommandItem, EventItem, QueryItem, SliceSpecification } from '../Model';
 import { SliceType } from '../Model';
 import { type ObservedEvent } from './redeliverableGivens';
 export interface WhenSectionProps {
@@ -12,5 +12,6 @@ export interface WhenSectionProps {
     inputEvents?: readonly ObservedEvent[];
     trigger?: AutomationTrigger;
     sliceName?: string;
+    queries?: readonly QueryItem[];
 }
-export declare const WhenSection: ({ sliceId, sliceType, specification, command, renamedCommandName, events, inputEvents, trigger, sliceName }: WhenSectionProps) => import("react").JSX.Element;
+export declare const WhenSection: ({ sliceId, sliceType, specification, command, renamedCommandName, events, inputEvents, trigger, sliceName, queries }: WhenSectionProps) => import("react").JSX.Element;

package/dist/Specifications/index.d.ts

@@ -19,3 +19,5 @@ export * from './eventKeyOf';
 export * from './SpecificationAddGroup';
 export * from './specificationValuesMemory';
 export * from './whenEventEditing';
+export * from './specificationQueryMode';
+export * from './queryArguments';

package/dist/Specifications/queryArguments.d.ts

@@ -0,0 +1,4 @@
+import type { JsonSchema } from '@cratis/components/types';
+import { type QueryItem } from '../Model';
+export declare const queryArgumentSchema: (query: Pick<QueryItem, 'parameters'>) => JsonSchema | undefined;
+export declare const queryReturnsMany: (query: Pick<QueryItem, 'parameters' | 'resultShape'>) => boolean;

package/dist/Specifications/specificationQueryMode.d.ts

@@ -0,0 +1,16 @@
+import { Guid } from '@cratis/fundamentals';
+import type { SliceSpecification } from '../Model';
+export interface SpecificationQueryModes {
+    get(specificationId: string): string | false | undefined;
+    set(specificationId: string, queryItemId: Guid | undefined): void;
+    clear(specificationId: string): void;
+    subscribe(listener: () => void): () => void;
+}
+export declare const createSpecificationQueryModes: () => SpecificationQueryModes;
+export declare const SpecificationQueryModesContext: import("react").Context<SpecificationQueryModes>;
+export interface SpecificationQueryMode {
+    isQueryMode: boolean;
+    queryItemId?: Guid;
+}
+export declare const useSpecificationQueryMode: (specification: Pick<SliceSpecification, 'id' | 'whenQuery'>) => SpecificationQueryMode;
+export declare const useSetSpecificationQuery: () => (specificationId: Guid, queryItemId: Guid | undefined) => void;

package/dist/event-model-document.schema.json

@@ -975,9 +975,20 @@
                     "$ref": "#/$defs/SpecificationRedelivery",
                     "description": "One of the given events, told again to the reaction of an automation or translator slice. When present, it is the whole When."
                 },
+                "whenQuery": {
+                    "$ref": "#/$defs/SpecificationWhenQuery",
+                    "description": "The query the specification runs as its action. When present, the specification is in query mode."
+                },
                 "givenReadModel": {
                     "$ref": "#/$defs/SpecificationReadModel"
                 },
+                "givenReadModels": {
+                    "type": "array",
+                    "description": "The read models a query-mode specification starts from, each with the values it holds.",
+                    "items": {
+                        "$ref": "#/$defs/SpecificationReadModel"
+                    }
+                },
                 "givenContexts": {
                     "type": "array",
                     "items": {
@@ -1000,6 +1011,13 @@
                     "$ref": "#/$defs/SpecificationReadModel",
                     "description": "The read model, and the values in it, the specification expects afterwards."
                 },
+                "thenReadModels": {
+                    "type": "array",
+                    "description": "What a query-mode specification expects the query to return: one read model for a query that returns one item, several otherwise.",
+                    "items": {
+                        "$ref": "#/$defs/SpecificationReadModel"
+                    }
+                },
                 "thenNoEvents": {
                     "type": "boolean",
                     "description": "The specification expects nothing to be appended. An empty Then means the outcome is not authored yet, so this is stated on its own."
@@ -1109,6 +1127,29 @@
                 }
             }
         },
+        "SpecificationWhenQuery": {
+            "type": "object",
+            "required": [
+                "queryItemId"
+            ],
+            "properties": {
+                "queryItemId": {
+                    "$ref": "#/$defs/Guid"
+                },
+                "name": {
+                    "type": "string"
+                },
+                "arguments": {
+                    "type": "object",
+                    "additionalProperties": true,
+                    "description": "What the query's parameters are given."
+                },
+                "legacy": {
+                    "type": "boolean",
+                    "description": "The query was stored on an older specification, which is shown but not edited."
+                }
+            }
+        },
         "SpecificationRedelivery": {
             "type": "object",
             "required": [