@sekiban/dcb-client 0.1.0

package/dist/executor.js

@@ -0,0 +1,515 @@
+import { assertJsonValue as assertCoreJsonValue } from "@sekiban/dcb-core";
+import { executeCommand, normalizeTag, DomainAuthoringError, } from "@sekiban/dcb-domain";
+import { ClientError, } from "./index";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isHttpResult(value) {
+    return isRecord(value) && typeof value.status === "number" && "body" in value;
+}
+function base64Json(value) {
+    const bytes = new TextEncoder().encode(JSON.stringify(value));
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function decodeJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        const binary = atob(value);
+        const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+        return JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        return value;
+    }
+}
+function bodyOf(value) {
+    return isHttpResult(value) ? value.body : value;
+}
+function httpFailure(value) {
+    const body = value.body;
+    const code = isRecord(body) && typeof body.code === "string" ? body.code : "http_error";
+    const message = isRecord(body) && typeof body.error === "string" ? body.error : `HTTP ${value.status}`;
+    return new ClientError(code, message, {
+        status: value.status,
+        partial: isRecord(body) ? body.partial : undefined,
+    });
+}
+function successfulBody(value) {
+    if (isHttpResult(value)) {
+        if (value.status < 200 || value.status >= 300)
+            throw httpFailure(value);
+        return value.body;
+    }
+    return value;
+}
+async function responseResult(response) {
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        body = { code: "transport", error: `HTTP ${response.status}` };
+    }
+    const headers = {};
+    response.headers.forEach((value, key) => { headers[key] = value; });
+    return { status: response.status, headers, body };
+}
+function v1Envelope(request) {
+    return {
+        version: 1,
+        eventCandidates: request.candidates.map((candidate) => ({
+            payload: base64Json(candidate.payload),
+            eventPayloadName: candidate.eventPayloadName,
+            tags: [...candidate.tags],
+        })),
+        consistencyTags: request.consistency.map((entry) => ({
+            tag: entry.tag,
+            lastSortableUniqueId: entry.lastSortableUniqueId,
+        })),
+    };
+}
+function fetcherFrom(bindings) {
+    const selected = bindings.fetch ?? bindings.RUNTIME?.fetch ?? bindings.runtime?.fetch;
+    if (selected === undefined)
+        throw new ClientError("transport", "In-process runtime fetch binding is missing");
+    const owner = bindings.fetch !== undefined ? bindings : bindings.RUNTIME ?? bindings.runtime;
+    return owner === undefined ? selected : selected.bind(owner);
+}
+function makeHttpTransport(options) {
+    const baseUrl = options.baseUrl.replace(/\/$/, "");
+    const fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    const headers = { "content-type": "application/json", ...(options.headers ?? {}) };
+    const call = async (path, body, signal) => {
+        const response = await fetchImpl(`${baseUrl}${path}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal,
+        });
+        return responseResult(response);
+    };
+    const read = async (path, body, signal) => {
+        const result = await call(path, body, signal);
+        return result.status >= 200 && result.status < 300 ? result.body : result;
+    };
+    return Object.freeze({
+        serviceId: options.serviceId,
+        readTagState: (request, signal) => read("/api/sekiban/serialized/tag-state", request, signal),
+        readTagLatestSortable: (request, signal) => read("/api/sekiban/serialized/tag-latest-sortable", request, signal),
+        commit: (request, signal) => call("/api/sekiban/serialized/commit", v1Envelope(request), signal),
+        query: (request, signal) => read("/api/sekiban/serialized/query", request, signal),
+        listQuery: (request, signal) => read("/api/sekiban/serialized/list-query", request, signal),
+    });
+}
+/** Use the Worker's internal service binding; no public HTTP hop is introduced. */
+export function createInProcessTransport(env, options = {}) {
+    return makeHttpTransport({ baseUrl: "https://runtime.internal", fetch: fetcherFrom(env), serviceId: options.serviceId });
+}
+export function createHttpTransport(options) {
+    return makeHttpTransport(options);
+}
+function cloudResult(value, credentials = []) {
+    if (isHttpResult(value) && (value.status === 401 || value.status === 403)) {
+        throw new ClientError("credential.rejected", "SekibanCloud credential was rejected", { status: value.status });
+    }
+    if (isHttpResult(value) && (value.status < 200 || value.status >= 300)) {
+        const body = value.body;
+        const candidateCode = isRecord(body) && typeof body.code === "string" ? body.code : undefined;
+        const code = candidateCode !== undefined && /^[A-Za-z0-9_.-]{1,64}$/.test(candidateCode) &&
+            !credentials.some((credential) => credential.length > 0 && candidateCode.includes(credential))
+            ? candidateCode
+            : "transport";
+        return {
+            ...value,
+            headers: {},
+            body: { code, error: "SekibanCloud request failed" },
+        };
+    }
+    return value;
+}
+export function createSekibanCloudTransport(options) {
+    const base = makeHttpTransport({
+        baseUrl: options.BaseUrl,
+        serviceId: options.ServiceId,
+        fetch: options.fetch,
+        headers: {
+            "X-Sekiban-Service-Id": options.ServiceId,
+            "X-Sekiban-Credential-Id": options.CredentialId,
+            "X-Sekiban-Credential-Secret": options.CredentialSecret,
+        },
+    });
+    const protect = async (operation) => {
+        try {
+            return cloudResult(await operation(), [options.CredentialId, options.CredentialSecret]);
+        }
+        catch (error) {
+            if (error instanceof ClientError && error.code === "credential.rejected")
+                throw error;
+            throw new ClientError("transport", "SekibanCloud request failed");
+        }
+    };
+    return Object.freeze({
+        serviceId: options.ServiceId,
+        readTagState: (request, signal) => protect(() => base.readTagState(request, signal)),
+        readTagLatestSortable: (request, signal) => protect(() => base.readTagLatestSortable(request, signal)),
+        commit: (request, signal) => protect(() => base.commit(request, signal)),
+        query: (request, signal) => protect(() => base.query(request, signal)),
+        listQuery: (request, signal) => protect(() => base.listQuery(request, signal)),
+    });
+}
+function snapshotKey(projectorId, tag) {
+    return `${projectorId}\u0000${tag.id}`;
+}
+function snapshotReaderFrom(executor, supplied, readMode) {
+    const isSnapshotArray = (value) => Array.isArray(value);
+    const array = isSnapshotArray(supplied) ? supplied : undefined;
+    const reader = supplied !== undefined && !isSnapshotArray(supplied) ? supplied : undefined;
+    const byCell = new Map();
+    const byTag = new Map();
+    for (const snapshot of array ?? []) {
+        byCell.set(snapshotKey(snapshot.projectorId, snapshot.tag), snapshot);
+        byTag.set(snapshot.tag.id, snapshot);
+    }
+    const missing = (projectorId, tag) => {
+        throw new DomainAuthoringError("executor.snapshot_missing", `Snapshot is missing for ${projectorId ?? "exists"}/${tag.id}`);
+    };
+    const fallbackRead = async (projector, tag) => {
+        if (array !== undefined) {
+            const found = byCell.get(snapshotKey(projector.id, tag));
+            if (found !== undefined)
+                return found;
+            if (readMode === "snapshot-only")
+                return missing(projector.id, tag);
+        }
+        if (reader !== undefined) {
+            try {
+                return await reader.read(projector, tag);
+            }
+            catch (error) {
+                if (readMode === "snapshot-only")
+                    return missing(projector.id, tag);
+                throw error;
+            }
+        }
+        if (readMode === "snapshot-only")
+            return missing(projector.id, tag);
+        return executor.readState(projector, tag);
+    };
+    const fallbackExists = async (tag) => {
+        const found = byTag.get(tag.id);
+        if (found !== undefined)
+            return found.exists;
+        if (reader !== undefined && reader.exists !== undefined) {
+            return reader.exists(tag);
+        }
+        if (readMode === "snapshot-only")
+            return missing(undefined, tag);
+        return (await executor.exists(tag)).exists;
+    };
+    const fallbackHead = async (tag) => {
+        const found = byTag.get(tag.id);
+        if (found !== undefined)
+            return found.head;
+        if (reader !== undefined && reader.head !== undefined) {
+            return reader.head(tag);
+        }
+        if (readMode === "snapshot-only")
+            return missing(undefined, tag);
+        return (await executor.exists(tag)).head;
+    };
+    return { read: fallbackRead, exists: fallbackExists, head: fallbackHead };
+}
+function normalizedResponse(value, requestedTagStateId) {
+    const body = bodyOf(value);
+    if (!isRecord(body) || typeof body.payload === "undefined") {
+        throw new ClientError("invalid_read_snapshot", "Tag-state response was not an object");
+    }
+    if (typeof body.version !== "number" || typeof body.lastSortedUniqueId !== "string" ||
+        typeof body.tagGroup !== "string" || typeof body.tagContent !== "string" || typeof body.tagProjector !== "string") {
+        throw new ClientError("invalid_read_snapshot", "Tag-state response had invalid identity or head fields");
+    }
+    const stateId = `${body.tagGroup}:${body.tagContent}:${body.tagProjector}`;
+    if (stateId !== requestedTagStateId)
+        throw new ClientError("incoherent_read_snapshot", "Tag-state identity changed during one read", { status: 500 });
+    return body;
+}
+function writtenEvents(value) {
+    const body = bodyOf(value);
+    return isRecord(body) && Array.isArray(body.writtenEvents)
+        ? body.writtenEvents.filter(isRecord)
+        : [];
+}
+function tagWriteResults(value) {
+    const body = bodyOf(value);
+    return isRecord(body) && Array.isArray(body.tagWriteResults)
+        ? body.tagWriteResults.filter(isRecord)
+        : [];
+}
+function stringField(value, key) {
+    return isRecord(value) && typeof value[key] === "string" ? value[key] : undefined;
+}
+function responseHead(value, events) {
+    const direct = stringField(bodyOf(value), "head");
+    if (direct !== undefined)
+        return direct;
+    const suids = events.flatMap((event) => [event.sortableUniqueIdValue, event.suid, event.lastSortableUniqueId])
+        .filter((candidate) => typeof candidate === "string");
+    return suids.sort().at(-1) ?? "";
+}
+function writtenEventHeads(value, candidateEvents) {
+    const heads = new Map();
+    for (const [index, written] of writtenEvents(value).entries()) {
+        const suid = [written.sortableUniqueIdValue, written.suid, written.lastSortableUniqueId]
+            .find((candidate) => typeof candidate === "string");
+        if (suid === undefined)
+            continue;
+        const writtenTags = Array.isArray(written.tags)
+            ? written.tags.filter((tag) => typeof tag === "string")
+            : [];
+        const candidateTags = candidateEvents[index]?.tags.map((tag) => tag.id) ?? [];
+        for (const tag of writtenTags.length > 0 ? writtenTags : candidateTags) {
+            const previous = heads.get(tag);
+            if (previous === undefined || suid > previous)
+                heads.set(tag, suid);
+        }
+    }
+    return heads;
+}
+function responseHeads(value, claims, fallbackHead, updatedTags, candidateEvents) {
+    const responseBody = bodyOf(value);
+    const raw = isRecord(responseBody) ? responseBody.heads : undefined;
+    const rawHeads = new Map();
+    if (Array.isArray(raw)) {
+        for (const item of raw) {
+            if (!isRecord(item) || typeof item.tag !== "string" || typeof item.head !== "string")
+                continue;
+            rawHeads.set(normalizeTag(item.tag).id, item.head);
+        }
+    }
+    const writtenHeads = writtenEventHeads(value, candidateEvents);
+    if (claims.length === 0 && rawHeads.size > 0) {
+        return [...rawHeads].map(([tag, head]) => ({ tag: normalizeTag(tag), head }));
+    }
+    return claims.map((claim) => {
+        const writtenHead = writtenHeads.get(claim.tag.id);
+        const rawHead = rawHeads.get(claim.tag.id);
+        return {
+            tag: claim.tag,
+            head: updatedTags.has(claim.tag.id) ? writtenHead ?? rawHead ?? fallbackHead : claim.head ?? "",
+        };
+    });
+}
+function conflictDetails(value) {
+    const body = bodyOf(value);
+    const raw = isRecord(body) && Array.isArray(body.conflicts) ? body.conflicts : [];
+    return raw.flatMap((item) => {
+        if (!isRecord(item) || typeof item.tag !== "string" || typeof item.expectedHead !== "string")
+            return [];
+        return [{
+                tag: normalizeTag(item.tag),
+                expectedHead: item.expectedHead,
+                ...(typeof item.actualHead === "string" ? { actualHead: item.actualHead } : {}),
+            }];
+    });
+}
+function envelopeFor(candidate) {
+    const eventTags = new Set(candidate.events.flatMap((event) => event.tags.map((tag) => tag.id)));
+    const consistency = new Map();
+    for (const claim of candidate.readClaims) {
+        if (claim.head !== null && eventTags.has(claim.tag.id) && !consistency.has(claim.tag.id)) {
+            consistency.set(claim.tag.id, claim.head);
+        }
+    }
+    return {
+        candidates: candidate.events.map((event) => ({
+            eventId: `authoring:${event.ordinal}`,
+            eventPayloadName: event.eventName,
+            payload: assertCoreJsonValue(event.payload),
+            tags: event.tags.map((tag) => tag.id),
+        })),
+        consistency: [...consistency].map(([tag, lastSortableUniqueId]) => ({ tag, lastSortableUniqueId })),
+    };
+}
+function commitDecision(value) {
+    if (!isHttpResult(value))
+        return { kind: "accepted" };
+    const body = value.body;
+    const code = stringField(body, "code");
+    if (value.status >= 200 && value.status < 300)
+        return { kind: "accepted" };
+    if (value.status === 409 || code === "consistency_conflict")
+        return { kind: "consistency-conflict", error: body };
+    if (value.status >= 500 || code === "unknown_outcome")
+        return { kind: "unknown", error: body };
+    return { kind: "rejected", error: body };
+}
+function errorText(error) {
+    if (error instanceof Error)
+        return error.message;
+    return isRecord(error) && typeof error.error === "string" ? error.error : String(error);
+}
+export function createSekibanExecutor(transport, options = {}) {
+    const scopeMismatch = options.serviceId !== undefined && transport.serviceId !== undefined && options.serviceId !== transport.serviceId;
+    const clock = options.clock ?? (() => Date.now());
+    const executor = {};
+    const readState = async (projector, tag, readOptions = {}) => {
+        const tagValue = normalizeTag(tag);
+        const stateId = `${tagValue.id}:${projector.id}`;
+        const raw = await transport.readTagState({ tagStateId: stateId }, readOptions.signal);
+        const response = normalizedResponse(raw, stateId);
+        const decoded = decodeJson(response.payload);
+        const empty = isRecord(decoded) && decoded.status === "empty";
+        const state = empty
+            ? (typeof projector.initialState === "function" ? projector.initialState() : projector.initialState)
+            : decoded;
+        return Object.freeze({
+            projectorId: projector.id,
+            tag: tagValue,
+            head: response.lastSortedUniqueId.length === 0 ? null : response.lastSortedUniqueId,
+            state,
+            exists: !empty,
+        });
+    };
+    const exists = async (tag, readOptions = {}) => {
+        if (transport.readTagLatestSortable === undefined)
+            throw new ClientError("transport", "Transport does not implement exists reads");
+        const tagValue = normalizeTag(tag);
+        const raw = await transport.readTagLatestSortable({ tag: tagValue.id }, readOptions.signal);
+        const value = successfulBody(raw);
+        if (typeof value.lastSortableUniqueId !== "string" || typeof value.exists !== "boolean") {
+            throw new ClientError("invalid_read_snapshot", "Latest-sortable response was invalid");
+        }
+        return Object.freeze({
+            projectorId: "exists",
+            tag: tagValue,
+            head: value.lastSortableUniqueId.length === 0 ? null : value.lastSortableUniqueId,
+            state: undefined,
+            exists: value.exists,
+        });
+    };
+    const query = async (request, readOptions = {}) => successfulBody(await transport.query(request, readOptions.signal));
+    const listQuery = async (request, readOptions = {}) => successfulBody(await transport.listQuery(request, readOptions.signal));
+    const execute = async (command, input, executeOptions = {}) => {
+        if (scopeMismatch)
+            return { kind: "invalid", attempts: 0, code: "scope.mismatch", error: "Executor service scope does not match its transport" };
+        const snapshots = snapshotReaderFrom(executor, executeOptions.snapshots, executeOptions.readMode ?? "read-through");
+        const maxConflictRetries = executeOptions.readMode === "snapshot-only" ? 0 : executeOptions.maxConflictRetries ?? 1;
+        let commitAttempts = 0;
+        let lastResponse;
+        try {
+            const result = await executeCommand(command, input, {
+                timeProvider: { now: clock },
+                snapshots,
+                maxConflictRetries,
+                commit: async (candidate) => {
+                    commitAttempts += 1;
+                    const raw = await transport.commit(envelopeFor(candidate), executeOptions.signal);
+                    lastResponse = raw;
+                    const decision = commitDecision(raw);
+                    if (decision.kind === "consistency-conflict") {
+                        return commitAttempts > maxConflictRetries
+                            ? { kind: "rejected", error: decision.error }
+                            : { kind: "consistency-conflict", error: decision.error };
+                    }
+                    if (decision.kind === "unknown")
+                        return { kind: "unknown", error: decision.error };
+                    if (decision.kind === "rejected")
+                        return { kind: "rejected", error: decision.error };
+                    return { kind: "accepted" };
+                },
+                onPropagation: undefined,
+            });
+            if (result.status === "accepted") {
+                const events = writtenEvents(lastResponse);
+                const head = responseHead(lastResponse, events);
+                const updatedTags = new Set(result.envelope?.events.flatMap((event) => event.tags.map((tag) => tag.id)) ?? []);
+                return {
+                    kind: "committed",
+                    attempts: result.attempts,
+                    status: isHttpResult(lastResponse) ? lastResponse.status : 200,
+                    response: bodyOf(lastResponse),
+                    writtenEvents: events,
+                    tagWriteResults: tagWriteResults(lastResponse),
+                    head,
+                    heads: responseHeads(lastResponse, result.envelope?.readClaims.map((claim) => ({ tag: claim.tag, head: claim.head })) ?? [], head, updatedTags, result.envelope?.events ?? []),
+                };
+            }
+            if (result.status === "discarded") {
+                if (result.decision.kind === "none")
+                    return { kind: "noop", attempts: result.attempts, reason: result.decision.reason };
+                const details = result.decision.kind === "reject" && typeof result.decision.details === "string"
+                    ? result.decision.details
+                    : undefined;
+                return {
+                    kind: "rejected",
+                    attempts: result.attempts,
+                    error: result.decision.kind === "reject" ? result.decision.reason : "Command was rejected",
+                    code: result.decision.kind === "reject" ? details ?? result.decision.code : "command_rejected",
+                };
+            }
+            if (result.status === "rejected") {
+                const conflict = result.error !== undefined && lastResponse !== undefined && isHttpResult(lastResponse)
+                    && (lastResponse.status === 409 || stringField(lastResponse.body, "code") === "consistency_conflict");
+                if (conflict) {
+                    return {
+                        kind: "conflict",
+                        attempts: result.attempts,
+                        status: isHttpResult(lastResponse) ? lastResponse.status : undefined,
+                        code: "consistency_conflict",
+                        response: bodyOf(lastResponse),
+                        conflicts: conflictDetails(lastResponse),
+                    };
+                }
+                if (result.error !== undefined) {
+                    return { kind: "rejected", attempts: result.attempts, error: errorText(result.error), code: stringField(result.error, "code") };
+                }
+                const details = result.decision.kind === "reject" && typeof result.decision.details === "string"
+                    ? result.decision.details
+                    : undefined;
+                return {
+                    kind: "rejected",
+                    attempts: result.attempts,
+                    error: result.decision.kind === "reject" ? result.decision.reason : "Command was rejected",
+                    code: result.decision.kind === "reject" ? details ?? result.decision.code : "command_rejected",
+                };
+            }
+            if (result.status === "unknown")
+                return { kind: "timeout", attempts: result.attempts, code: "unknown_outcome", error: errorText(result.error) };
+            return { kind: "rejected", attempts: result.attempts, error: `Command ${command.id} was rejected`, code: "command_rejected" };
+        }
+        catch (error) {
+            // The facade and the authored sample can resolve separate package
+            // copies in a Worker bundle, so preserve the domain error code across
+            // that package boundary instead of relying on instanceof alone.
+            const authoringCode = error instanceof DomainAuthoringError
+                ? error.code
+                : isRecord(error) && typeof error.code === "string" ? error.code : undefined;
+            if (authoringCode === "executor.snapshot_missing") {
+                return { kind: "invalid", attempts: 0, code: authoringCode, error: errorText(error) };
+            }
+            // Command input validation is a typed application rejection, not a
+            // transport failure. The executor facade must preserve the public
+            // invalid-command contract used by the meeting-room API.
+            if (authoringCode === "COMMAND_INPUT_INVALID") {
+                return { kind: "invalid", attempts: 1, code: "invalid_command_input", error: errorText(error) };
+            }
+            if (error instanceof ClientError) {
+                if (error.code === "timeout" || error.code === "aborted")
+                    return { kind: "timeout", attempts: 1, code: error.code, error: error.message };
+                return { kind: "invalid", attempts: 1, status: error.status, code: error.code, error: error.message };
+            }
+            return { kind: "transport", attempts: 1, error: errorText(error) };
+        }
+    };
+    executor.readState = readState;
+    executor.exists = exists;
+    executor.query = query;
+    executor.listQuery = listQuery;
+    executor.transport = transport;
+    executor.execute = execute;
+    return Object.freeze(executor);
+}