@sekiban/dcb-domain 0.1.0

package/dist/command.js

@@ -0,0 +1,64 @@
+import { DomainAuthoringError, V1_REJECT_ERROR_CODES, } from "./types";
+export function read(projector, tag) {
+    return readSet({ kind: "state", projectorId: projector.id, projector, tag });
+}
+export function readExists(tag) {
+    return readSet({ kind: "exists", tag });
+}
+export const readTag = readExists;
+export function readSet(...declarations) {
+    const flattened = declarations.flatMap((declaration) => "claims" in declaration ? [...declaration.claims] : [declaration]);
+    const claims = flattened.map((declaration) => Object.freeze({
+        ...declaration,
+        tag: Object.freeze(declaration.tag),
+    }));
+    const tags = [...new Map(claims.map((claim) => [claim.tag.id, claim.tag])).values()];
+    const has = (kind, projectorId, tag) => claims.some((claim) => claim.kind === kind &&
+        claim.tag.id === tag.id &&
+        (kind === "exists" || claim.projectorId === projectorId));
+    return Object.freeze({ claims: Object.freeze(claims), tags: Object.freeze(tags), has });
+}
+export function command(options) {
+    if (options.id.length === 0)
+        throw new DomainAuthoringError("COMMAND_ID_REQUIRED", "Command id is required");
+    const parseInput = (value) => {
+        try {
+            return options.input.parse(value);
+        }
+        catch (error) {
+            throw new DomainAuthoringError("COMMAND_INPUT_INVALID", `Command ${options.id} input was rejected`, { cause: error });
+        }
+    };
+    const execute = (value, context) => {
+        const parsed = parseInput(value);
+        const declarations = options.reads(parsed);
+        if (!declarations || typeof declarations.has !== "function") {
+            throw new DomainAuthoringError("READ_SET_INVALID", `Command ${options.id} reads() must return a ReadSet`);
+        }
+        return options.handle(parsed, context);
+    };
+    return Object.freeze({
+        id: options.id,
+        input: options.input,
+        parseInput,
+        reads: options.reads,
+        handle: options.handle,
+        execute,
+    });
+}
+export function done(value) {
+    return Object.freeze({ kind: "done", ...(value === undefined ? {} : { value }) });
+}
+export function none(reason) {
+    return Object.freeze({ kind: "none", ...(reason === undefined ? {} : { reason }) });
+}
+export function reject(rejectKind, reason, details) {
+    return Object.freeze({
+        kind: "reject",
+        rejectKind,
+        reason,
+        code: V1_REJECT_ERROR_CODES[rejectKind],
+        ...(details === undefined ? {} : { details }),
+    });
+}
+export const terminal = { done, none, reject };

package/dist/domain.d.ts

@@ -0,0 +1,27 @@
+import type { EventDefinition, EventUnion } from "./event.js";
+import type { CommandDefinition } from "./command.js";
+import type { ProjectorDefinition } from "./state.js";
+export type DomainEventInput = EventDefinition | EventUnion;
+export interface DomainViewDefinition {
+    readonly id: string;
+    readonly source: string;
+    readonly projector?: string;
+    /** Domain-owned half of the per-view delivery policy. */
+    readonly deliveryClass?: "immediate-preferred" | "queued";
+}
+export interface AuthoringDomain<Events extends readonly EventDefinition[] = readonly EventDefinition[], Projectors extends readonly unknown[] = readonly ProjectorDefinition[], Commands extends readonly unknown[] = readonly CommandDefinition[]> {
+    readonly events: Events;
+    readonly projectors: Projectors;
+    readonly commands: Commands;
+    readonly views: readonly DomainViewDefinition[];
+    readonly eventByType: ReadonlyMap<string, EventDefinition>;
+    readonly eventByName: ReadonlyMap<string, EventDefinition>;
+}
+export interface DomainOptions<Events extends readonly DomainEventInput[] = readonly DomainEventInput[], Projectors extends readonly unknown[] = readonly ProjectorDefinition[], Commands extends readonly unknown[] = readonly CommandDefinition[]> {
+    readonly events?: Events;
+    readonly eventUnions?: readonly EventUnion[];
+    readonly projectors?: Projectors;
+    readonly commands?: Commands;
+    readonly views?: readonly DomainViewDefinition[];
+}
+export declare function domain<const Events extends readonly DomainEventInput[], const Projectors extends readonly unknown[], const Commands extends readonly unknown[]>(options: DomainOptions<Events, Projectors, Commands>): AuthoringDomain<Extract<Events[number], EventDefinition> extends never ? readonly EventDefinition[] : readonly EventDefinition[], Projectors, Commands>;

package/dist/domain.js

@@ -0,0 +1,79 @@
+import { DomainRegistrationError, } from "./types";
+function flattenEvents(values) {
+    const result = [];
+    for (const value of values) {
+        if ("kind" in value && value.kind === "event-union")
+            result.push(...value.events);
+        else
+            result.push(value);
+    }
+    return result;
+}
+export function domain(options) {
+    const eventInputs = [
+        ...(options.events ?? []),
+        ...(options.eventUnions ?? []),
+    ];
+    const events = flattenEvents(eventInputs);
+    const projectors = [...(options.projectors ?? [])];
+    const commands = [...(options.commands ?? [])];
+    const views = [...(options.views ?? [])];
+    const collisions = [];
+    const identityOwners = new Map();
+    const register = (identity, owner) => {
+        const previous = identityOwners.get(identity);
+        if (previous !== undefined)
+            collisions.push(`${identity} (${previous}, ${owner})`);
+        identityOwners.set(identity, owner);
+    };
+    for (const definition of events)
+        register(`event:${definition.eventType}`, definition.eventType);
+    for (const commandValue of commands) {
+        const definition = commandValue;
+        register(`command:${definition.id}`, definition.id);
+    }
+    for (const projectorValue of projectors) {
+        const definition = projectorValue;
+        register(`projector:${definition.id}`, definition.id);
+    }
+    for (const view of views)
+        register(`view:${view.id}`, view.id);
+    if (collisions.length > 0)
+        throw new DomainRegistrationError("Domain contains duplicate definition identities", collisions);
+    const eventByType = new Map();
+    const eventByName = new Map();
+    for (const definition of events) {
+        if (eventByType.has(definition.eventType))
+            throw new DomainRegistrationError(`Duplicate event identity ${definition.eventType}`, [definition.eventType]);
+        eventByType.set(definition.eventType, definition);
+        if (!eventByName.has(definition.name))
+            eventByName.set(definition.name, definition);
+    }
+    for (const projectorValue of projectors) {
+        const projector = projectorValue;
+        for (const eventType of projector.eventTypes) {
+            const definition = eventByType.get(eventType);
+            if (definition === undefined)
+                throw new DomainRegistrationError(`Projector ${projector.id} references unregistered ${eventType}`, [eventType]);
+            if (definition.tagFamilies.length > 0 && !definition.tagFamilies.includes(projector.tag.family)) {
+                throw new DomainRegistrationError(`Projector ${projector.id} has a source/family mismatch for ${eventType}`, [eventType]);
+            }
+        }
+    }
+    for (const view of views) {
+        if (!projectors.some((projectorValue) => {
+            const projector = projectorValue;
+            return projector.id === view.source || projector.id === view.projector;
+        })) {
+            throw new DomainRegistrationError(`View ${view.id} has no registered source projector`, [view.id]);
+        }
+    }
+    return Object.freeze({
+        events: Object.freeze(events),
+        projectors: Object.freeze(projectors),
+        commands: Object.freeze(commands),
+        views: Object.freeze(views),
+        eventByType,
+        eventByName,
+    });
+}

package/dist/event.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { type EventOf, type JsonValue, type Tag, type TagDeriver, type TagFamily, type TagFamilyOfDeriver } from "./types.js";
+export declare function isEventPayload(value: unknown): boolean;
+export interface EventDefinition<Name extends string = string, Schema extends z.ZodTypeAny = z.ZodTypeAny, Family extends string = string> {
+    readonly name: Name;
+    readonly eventPayloadName: Name;
+    readonly eventType: Name | string;
+    readonly key: Name | string;
+    readonly schema: Schema;
+    readonly tags: (payload: z.infer<Schema>) => readonly Tag<Family>[];
+    readonly make: (payload: unknown) => EventOf<EventDefinition<Name, Schema, Family>>;
+    readonly parse: (payload: unknown) => z.infer<Schema>;
+    readonly create: (payload: unknown) => RuntimeEventValue;
+    readonly construct: (payload: unknown) => RuntimeEventValue;
+    readonly tagFamilies: readonly string[];
+}
+export interface RuntimeEventValue {
+    readonly eventName: string;
+    readonly eventPayloadName: string;
+    readonly eventType: string;
+    readonly payload: JsonValue;
+    readonly tags: readonly Tag[];
+}
+export interface EventOptions<Payload, Deriver extends TagDeriver<Payload>> {
+    readonly tags: Deriver;
+    /** Removed by G32: define a distinct event name for each payload revision. */
+    readonly version?: never;
+    readonly tagFamily?: TagFamily | string;
+}
+export declare function event<const Name extends string, Schema extends z.ZodTypeAny, Deriver extends TagDeriver<z.infer<Schema>>>(name: Name, schema: Schema, options: EventOptions<z.infer<Schema>, Deriver>): EventDefinition<Name, Schema, TagFamilyOfDeriver<Deriver>>;
+export interface EventUnion<Events extends readonly EventDefinition[] = readonly EventDefinition[]> {
+    readonly kind: "event-union";
+    readonly events: Events;
+    readonly eventTypes: readonly string[];
+    readonly discriminator?: string;
+    readonly schema: z.ZodType<EventOf<Events[number]>>;
+    readonly parse: (value: unknown) => EventOf<Events[number]>;
+    readonly safeParse: (value: unknown) => EventUnionSafeParse<EventOf<Events[number]>>;
+}
+export type EventUnionSafeParse<Value> = {
+    readonly success: true;
+    readonly data: Value;
+} | {
+    readonly success: false;
+    readonly error: z.ZodError;
+};
+export declare function eventUnion<const Events extends readonly EventDefinition[]>(events: Events): EventUnion<Events>;
+export declare function eventUnion<const Discriminator extends string, const Events extends readonly EventDefinition[]>(discriminator: Discriminator, events: Events): EventUnion<Events>;
+export type EventUnionOf<Union extends EventUnion> = EventOf<Union["events"][number]>;

package/dist/event.js

@@ -0,0 +1,178 @@
+import { z } from "zod";
+import { assertJsonValue, cloneAndFreeze, DomainAuthoringError, normalizeTag, } from "./types";
+const brandedPayloads = new WeakSet();
+const CAMEL_CASE_KEY = /^[a-z][A-Za-z0-9]*$/;
+const FORBIDDEN_PAYLOAD_DISCRIMINATORS = new Set(["eventType", "eventName", "eventPayloadName"]);
+function rememberPayload(value) {
+    if (typeof value === "object" && value !== null)
+        brandedPayloads.add(value);
+    return value;
+}
+export function isEventPayload(value) {
+    return typeof value === "object" && value !== null && brandedPayloads.has(value);
+}
+/**
+ * C# serialized payloads use JsonNamingPolicy.CamelCase and fail on a
+ * case-mismatched member. Check the authoring schema once so callers cannot
+ * accidentally publish a PascalCase or discriminator-bearing wire shape.
+ */
+function assertCamelCaseSchemaKeys(schema, path = "$") {
+    const definition = schema;
+    const def = definition.def;
+    if (def?.type === "object" && typeof def.shape === "object" && def.shape !== null) {
+        for (const [key, child] of Object.entries(def.shape)) {
+            if (!CAMEL_CASE_KEY.test(key) || FORBIDDEN_PAYLOAD_DISCRIMINATORS.has(key)) {
+                throw new DomainAuthoringError("EVENT_PAYLOAD_CAMEL_CASE_REQUIRED", `Event schema member ${path}.${key} must be camelCase and must not be a type discriminator`);
+            }
+            assertCamelCaseSchemaKeys(child, `${path}.${key}`);
+        }
+        return;
+    }
+    if (def?.type === "array" && def.element instanceof z.ZodType) {
+        assertCamelCaseSchemaKeys(def.element, `${path}[]`);
+        return;
+    }
+    if (def?.innerType instanceof z.ZodType) {
+        assertCamelCaseSchemaKeys(def.innerType, path);
+        return;
+    }
+    if (Array.isArray(def?.options)) {
+        for (const option of def.options)
+            if (option instanceof z.ZodType)
+                assertCamelCaseSchemaKeys(option, path);
+    }
+}
+export function event(name, schema, options) {
+    if (name.length === 0)
+        throw new DomainAuthoringError("EVENT_NAME_INVALID", "Event name must not be empty");
+    if (name.includes(":"))
+        throw new DomainAuthoringError("EVENT_NAME_INVALID", "Event name must not contain ':'");
+    if (Object.prototype.hasOwnProperty.call(options, "version")) {
+        throw new DomainAuthoringError("EVENT_VERSION_REMOVED", "Event version is removed; use a distinct event payload name");
+    }
+    const eventType = name;
+    assertCamelCaseSchemaKeys(schema);
+    const parse = (payload) => {
+        const parsed = schema.parse(payload);
+        assertJsonValue(parsed, "event-construction");
+        return parsed;
+    };
+    const make = (payload) => {
+        const parsed = cloneAndFreeze(parse(payload));
+        return rememberPayload(parsed);
+    };
+    const create = (payload) => {
+        const parsed = parse(payload);
+        const rawTags = options.tags(parsed);
+        if (!Array.isArray(rawTags))
+            throw new DomainAuthoringError("EVENT_TAGS_INVALID", `Event ${name} tags must be an array`);
+        const tags = rawTags.map(normalizeTag);
+        return Object.freeze({
+            eventName: name,
+            eventPayloadName: name,
+            eventType,
+            payload: assertJsonValue(parsed),
+            tags,
+        });
+    };
+    const tagFamilies = options.tagFamily === undefined
+        ? []
+        : [typeof options.tagFamily === "string" ? options.tagFamily : options.tagFamily.family];
+    return Object.freeze({
+        name,
+        eventPayloadName: name,
+        eventType,
+        key: eventType,
+        schema,
+        tags: (payload) => {
+            const rawTags = options.tags(payload);
+            if (!Array.isArray(rawTags))
+                throw new DomainAuthoringError("EVENT_TAGS_INVALID", `Event ${name} tags must be an array`);
+            return Object.freeze(rawTags.map(normalizeTag));
+        },
+        make,
+        parse,
+        create,
+        construct: create,
+        tagFamilies: Object.freeze(tagFamilies),
+    });
+}
+function parseUnion(events, value) {
+    let lastError;
+    for (const definition of events) {
+        try {
+            return definition.make(value);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw new DomainAuthoringError("EVENT_UNION_INVALID", "Value did not match any event in the union", { cause: lastError });
+}
+function schemaHasDiscriminator(schema, discriminator) {
+    const candidate = schema;
+    return candidate.def?.type === "object" &&
+        typeof candidate.def.shape === "object" &&
+        candidate.def.shape !== null &&
+        discriminator in candidate.def.shape;
+}
+export function eventUnion(discriminatorOrEvents, maybeEvents) {
+    const discriminator = typeof discriminatorOrEvents === "string" ? discriminatorOrEvents : undefined;
+    const events = (typeof discriminatorOrEvents === "string" ? maybeEvents : discriminatorOrEvents) ?? [];
+    if (events.length === 0)
+        throw new DomainAuthoringError("EVENT_UNION_EMPTY", "An event union must contain an event");
+    let zodUnion;
+    if (discriminator === undefined || events.every((definition) => schemaHasDiscriminator(definition.schema, discriminator))) {
+        try {
+            zodUnion = (discriminator === undefined
+                ? z.union(events.map((definition) => definition.schema))
+                : z.discriminatedUnion(discriminator, events.map((definition) => definition.schema)));
+        }
+        catch {
+            // A caller may use the optional discriminator only as an authoring label
+            // while supplying schemas that are not Zod discriminated objects. The
+            // branded parser below remains the fail-closed fallback for that surface.
+            zodUnion = undefined;
+        }
+    }
+    const parse = (value) => {
+        if (discriminator !== undefined && (typeof value !== "object" || value === null || Array.isArray(value))) {
+            throw new DomainAuthoringError("EVENT_UNION_DISCRIMINATOR_INVALID", `Union discriminator ${discriminator} was absent`);
+        }
+        if (discriminator !== undefined && zodUnion !== undefined) {
+            try {
+                zodUnion.parse(value);
+            }
+            catch (error) {
+                throw new DomainAuthoringError("EVENT_UNION_INVALID", "Value did not match the event discriminator", { cause: error });
+            }
+        }
+        return parseUnion(events, value);
+    };
+    const schema = zodUnion ?? z.any().refine((value) => {
+        try {
+            parse(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, { message: "Value did not match the event union" });
+    const safeParse = (value) => {
+        try {
+            return { success: true, data: parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof z.ZodError ? error : new z.ZodError([]) };
+        }
+    };
+    return Object.freeze({
+        kind: "event-union",
+        events,
+        eventTypes: Object.freeze(events.map((definition) => definition.eventType)),
+        ...(discriminator === undefined ? {} : { discriminator }),
+        schema,
+        parse,
+        safeParse,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export * from "./event.js";
+export * from "./state.js";
+export * from "./command.js";
+export * from "./domain.js";
+export * from "./session.js";
+export * from "./parse.js";
+export * from "./bridge.js";