@hunsu/protocol 0.1.0

package/dist/result.d.ts

@@ -0,0 +1,20 @@
+export type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+export type Option<T> = {
+    type: "some";
+    value: T;
+} | {
+    type: "none";
+};
+export declare function ok<T>(value: T): Result<T, never>;
+export declare function err<E>(error: E): Result<never, E>;
+export declare function some<T>(value: T): Option<T>;
+export declare function none<T = never>(): Option<T>;
+export declare function map<T, U, E>(result: Result<T, E>, transform: (value: T) => U): Result<U, E>;
+export declare function flatMap<T, U, E>(result: Result<T, E>, transform: (value: T) => Result<U, E>): Result<U, E>;
+export declare function fromNullable<T, E>(value: T | null | undefined, error: E): Result<T, E>;

package/dist/result.js

@@ -0,0 +1,21 @@
+export function ok(value) {
+    return { ok: true, value };
+}
+export function err(error) {
+    return { ok: false, error };
+}
+export function some(value) {
+    return { type: "some", value };
+}
+export function none() {
+    return { type: "none" };
+}
+export function map(result, transform) {
+    return result.ok ? ok(transform(result.value)) : result;
+}
+export function flatMap(result, transform) {
+    return result.ok ? transform(result.value) : result;
+}
+export function fromNullable(value, error) {
+    return value === null || value === undefined ? err(error) : ok(value);
+}

package/dist/workflow-helpers.d.ts

@@ -0,0 +1,31 @@
+import type { BoardProjection, Destination, DestinationId, TeamName, HunsuId, LineId, LineRecord, MoveRecord, NodeId, NodeRecord, RequestId, SkillDraftRecord } from "./model.ts";
+export declare const TEAM_NAME_POOL: string[];
+export declare function upsertById<T extends {
+    id: string;
+}>(items: T[], item: T): T[];
+export declare function unique<T>(items: T[]): T[];
+export declare function requestIdForLine(state: BoardProjection, lineId: LineId): RequestId;
+export declare function rootNodeId(requestId: RequestId): NodeId;
+export declare function nextNodeId(state: BoardProjection): NodeId;
+export declare function nextTeamName(state: BoardProjection): TeamName;
+export declare function nextForkLineId(lineId: LineId, hunsuId: HunsuId): LineId;
+export declare function requireRequest(state: BoardProjection, requestId: string): void;
+export declare function requireLine(state: BoardProjection, lineId: string): LineRecord;
+export declare function requirePlayableLine(line: LineRecord): void;
+export declare function requireNode(state: BoardProjection, nodeId: NodeId): NodeRecord;
+export declare function requireRootNode(state: BoardProjection, requestId: RequestId): NodeRecord;
+export declare function requireCurrentNode(state: BoardProjection, line: LineRecord): NodeRecord;
+export declare function requireMove(state: BoardProjection, moveId: string): MoveRecord;
+export declare function requireSkillDraft(state: BoardProjection, draftId: string): SkillDraftRecord;
+export declare function nodeForMove(state: BoardProjection, move: MoveRecord): NodeRecord | undefined;
+export declare function requireExistingDestination(state: BoardProjection, destinationId: DestinationId): Destination;
+export declare function requireDestinationInNode(node: NodeRecord, destinationId: DestinationId): Destination;
+export declare function requireClaimableDestination(state: BoardProjection, destinationId: DestinationId): Destination;
+export declare function requireBlockableDestination(state: BoardProjection, destinationId: DestinationId): Destination;
+export declare function requireBlockableDestinationInNode(node: NodeRecord, destinationId: DestinationId): Destination;
+export declare function requireBlockedDestinationInNode(node: NodeRecord, destinationId: DestinationId): Destination;
+export declare function requireReachibleDestinationInNode(node: NodeRecord, destinationId: DestinationId): Destination;
+export declare function isClosedDestination(destination: Destination): boolean;
+export declare function assertNonEmpty<T>(items: T[], message: string): void;
+export declare function assertSingleDestination<T>(items: T[], message: string): void;
+export declare function assertText(value: string, message: string): void;

package/dist/workflow-helpers.js

@@ -0,0 +1,193 @@
+import { DomainInvariantError, unwrapDomainModelResult } from "./errors.js";
+import { makeLineId, makeTeamName, makeNodeId, } from "./primitives.js";
+export const TEAM_NAME_POOL = [
+    "T1",
+    "Gen.G",
+    "Hanwha Life Esports",
+    "KT Rolster",
+    "Dplus KIA",
+    "DRX",
+    "Nongshim RedForce",
+    "BNK FearX",
+    "DN Freecs",
+    "OKSavingsBank BRION",
+    "Bilibili Gaming",
+    "JD Gaming",
+    "Top Esports",
+    "Anyone's Legend",
+    "Ninjas in Pyjamas",
+    "Weibo Gaming",
+    "Invictus Gaming",
+    "Team WE",
+    "LNG Esports",
+    "TT Gaming",
+    "LGD Gaming",
+    "EDward Gaming",
+    "Ultra Prime",
+    "Oh My God",
+    "Cloud9",
+    "Team Liquid",
+    "FlyQuest",
+    "Shopify Rebellion",
+    "100 Thieves",
+    "Dignitas",
+    "LYON",
+    "Sentinels",
+    "G2 Esports",
+    "Fnatic",
+    "Karmine Corp",
+    "Team Vitality",
+    "Team Heretics",
+    "GIANTX",
+    "Movistar KOI",
+    "SK Gaming",
+    "Natus Vincere",
+    "Rogue"
+];
+export function upsertById(items, item) {
+    if (items.some(existing => existing.id === item.id)) {
+        return items.map(existing => (existing.id === item.id ? item : existing));
+    }
+    return [...items, item];
+}
+export function unique(items) {
+    return Array.from(new Set(items));
+}
+export function requestIdForLine(state, lineId) {
+    return requireLine(state, lineId).requestId;
+}
+export function rootNodeId(requestId) {
+    return unwrapDomainModelResult(makeNodeId(`${requestId}:root`));
+}
+export function nextNodeId(state) {
+    const highest = state.nodes.reduce((max, node) => {
+        const match = node.id.match(/^N(\d+)$/i);
+        return match ? Math.max(max, Number(match[1])) : max;
+    }, 0);
+    return unwrapDomainModelResult(makeNodeId(`N${String(highest + 1).padStart(4, "0")}`));
+}
+export function nextTeamName(state) {
+    const used = new Set(state.lines.map(line => line.teamName).filter((name) => Boolean(name)));
+    const available = TEAM_NAME_POOL.find(name => !used.has(name));
+    if (available) {
+        return unwrapDomainModelResult(makeTeamName(available));
+    }
+    return unwrapDomainModelResult(makeTeamName(`${TEAM_NAME_POOL[state.lines.length % TEAM_NAME_POOL.length]}-${state.lines.length + 1}`));
+}
+export function nextForkLineId(lineId, hunsuId) {
+    return unwrapDomainModelResult(makeLineId(`${lineId}/fork-${hunsuId}`));
+}
+export function requireRequest(state, requestId) {
+    if (!state.requests.some(request => request.id === requestId)) {
+        throw new DomainInvariantError(`Unknown request: ${requestId}`);
+    }
+}
+export function requireLine(state, lineId) {
+    const line = state.lines.find(candidate => candidate.id === lineId);
+    if (!line) {
+        throw new DomainInvariantError(`Unknown line: ${lineId}`);
+    }
+    return line;
+}
+export function requirePlayableLine(line) {
+    if (line.status !== "active") {
+        throw new DomainInvariantError(`TEAM line ${line.id} cannot continue from status ${line.status}`);
+    }
+}
+export function requireNode(state, nodeId) {
+    const node = state.nodes.find(candidate => candidate.id === nodeId);
+    if (!node) {
+        throw new DomainInvariantError(`Unknown node: ${nodeId}`);
+    }
+    return node;
+}
+export function requireRootNode(state, requestId) {
+    return requireNode(state, rootNodeId(requestId));
+}
+export function requireCurrentNode(state, line) {
+    return requireNode(state, line.currentNodeId);
+}
+export function requireMove(state, moveId) {
+    const move = state.moves.find(candidate => candidate.id === moveId);
+    if (!move) {
+        throw new DomainInvariantError(`Unknown MOVE: ${moveId}`);
+    }
+    return move;
+}
+export function requireSkillDraft(state, draftId) {
+    const draft = state.skillDrafts.find(candidate => candidate.id === draftId);
+    if (!draft) {
+        throw new DomainInvariantError(`Unknown Skill Draft: ${draftId}`);
+    }
+    return draft;
+}
+export function nodeForMove(state, move) {
+    return move.toNodeId ? state.nodes.find(node => node.id === move.toNodeId) : undefined;
+}
+export function requireExistingDestination(state, destinationId) {
+    const destination = state.destinations.find(candidate => candidate.id === destinationId);
+    if (!destination) {
+        throw new DomainInvariantError(`Unknown Destination: ${destinationId}`);
+    }
+    return destination;
+}
+export function requireDestinationInNode(node, destinationId) {
+    const destination = node.destinations.find(candidate => candidate.id === destinationId);
+    if (!destination) {
+        throw new DomainInvariantError(`Unknown Destination in node ${node.id}: ${destinationId}`);
+    }
+    return destination;
+}
+export function requireClaimableDestination(state, destinationId) {
+    const destination = requireExistingDestination(state, destinationId);
+    if (destination.status !== "pending" && destination.status !== "blocked") {
+        throw new DomainInvariantError(`Destination ${destinationId} cannot be claimed from status ${destination.status}`);
+    }
+    return destination;
+}
+export function requireBlockableDestination(state, destinationId) {
+    const destination = requireExistingDestination(state, destinationId);
+    if (isClosedDestination(destination)) {
+        throw new DomainInvariantError(`Destination ${destinationId} cannot be blocked from status ${destination.status}`);
+    }
+    return destination;
+}
+export function requireBlockableDestinationInNode(node, destinationId) {
+    const destination = requireDestinationInNode(node, destinationId);
+    if (isClosedDestination(destination)) {
+        throw new DomainInvariantError(`Destination ${destinationId} cannot be blocked from status ${destination.status}`);
+    }
+    return destination;
+}
+export function requireBlockedDestinationInNode(node, destinationId) {
+    const destination = requireDestinationInNode(node, destinationId);
+    if (destination.status !== "blocked") {
+        throw new DomainInvariantError(`Destination ${destinationId} cannot be unblocked from status ${destination.status}`);
+    }
+    return destination;
+}
+export function requireReachibleDestinationInNode(node, destinationId) {
+    const destination = requireDestinationInNode(node, destinationId);
+    if (isClosedDestination(destination)) {
+        throw new DomainInvariantError(`Destination ${destinationId} cannot be reached from status ${destination.status}`);
+    }
+    return destination;
+}
+export function isClosedDestination(destination) {
+    return destination.status === "reached" || destination.status === "canceled" || destination.status === "superseded";
+}
+export function assertNonEmpty(items, message) {
+    if (items.length === 0) {
+        throw new DomainInvariantError(message);
+    }
+}
+export function assertSingleDestination(items, message) {
+    if (items.length !== 1) {
+        throw new DomainInvariantError(message);
+    }
+}
+export function assertText(value, message) {
+    if (value.trim() === "") {
+        throw new DomainInvariantError(message);
+    }
+}

package/dist/workflow.d.ts

@@ -0,0 +1,10 @@
+import type { BoardProjection, Command, DomainEvent, ValidatedCommand } from "./model.ts";
+import { type DomainWorkflowError } from "./errors.ts";
+import { type Result } from "./result.ts";
+export { DomainInvariantError, type DomainWorkflowError } from "./errors.ts";
+export { cloneHarness, createDefaultHarness, createDefaultMemberConfig, getHarnessMemberConfig, isExecutableHarness, validateHarness, validateExecutableHarness } from "./protocol-validation.ts";
+export { emptyBoardProjection, projectBoard, projectEvent, tryProjectBoard, validateEventStream } from "./projection.ts";
+export declare function tryHandleCommand(command: Command, state?: BoardProjection): Result<DomainEvent[], DomainWorkflowError>;
+export declare function tryApplyCommand(events: DomainEvent[], command: Command): Result<DomainEvent[], DomainWorkflowError>;
+export declare function validateCommand(input: unknown): Result<ValidatedCommand, DomainWorkflowError>;
+export declare function validateDomainEvent(value: unknown): Result<DomainEvent, DomainWorkflowError>;