@sekiban/dcb-runtime 0.2.0 → 0.2.1

package/dist/http/IncidentMaintenance.js

@@ -0,0 +1,145 @@
+import { IncidentLifecycle, IncidentLifecycleError, normalizeIncidentIdentity, } from "../completeness/IncidentLifecycle";
+import { requestServiceIdentity, } from "../service/ServiceIdentityProvider";
+function json(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json; charset=utf-8" },
+    });
+}
+function error(status, code, message) {
+    return json({ error: message, code }, status);
+}
+function configuredToken(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const token = value.trim();
+    return token.length === 0 ? undefined : token;
+}
+async function digest(value) {
+    const bytes = new TextEncoder().encode(value);
+    return new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+}
+function fixedLengthEqual(left, right) {
+    let difference = left.length ^ right.length;
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        difference |= (left[index] ?? 0) ^ (right[index] ?? 0);
+    }
+    return difference === 0;
+}
+async function authenticated(request, token) {
+    const credential = request.headers.get("authorization") ?? "";
+    const suppliedToken = credential.startsWith("Bearer ") ? credential.slice("Bearer ".length) : "";
+    const [expectedDigest, suppliedDigest] = await Promise.all([digest(token), digest(suppliedToken)]);
+    return fixedLengthEqual(expectedDigest, suppliedDigest);
+}
+function boolFilter(value, name) {
+    if (value === null)
+        return undefined;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    throw new IncidentLifecycleError("incident_invalid_filter", 400, `${name} must be true or false`);
+}
+function parseFilters(url) {
+    const allowed = new Set(["state", "owner", "unowned", "overdue", "observedAfterClose"]);
+    let unknown = false;
+    url.searchParams.forEach((_value, key) => {
+        if (!allowed.has(key))
+            unknown = true;
+    });
+    if (unknown)
+        throw new IncidentLifecycleError("incident_invalid_filter", 400, "Unknown incident list filter");
+    const state = url.searchParams.get("state");
+    if (state !== null && !["OPEN", "ACKNOWLEDGED", "CORRECTION_RECORDED", "CLOSED", "REOPENED"].includes(state)) {
+        throw new IncidentLifecycleError("incident_invalid_filter", 400, "state is invalid");
+    }
+    const owner = url.searchParams.get("owner");
+    if (owner !== null) {
+        const normalizedOwner = owner.trim();
+        if (normalizedOwner.length === 0) {
+            throw new IncidentLifecycleError("incident_invalid_filter", 400, "owner must be non-empty");
+        }
+        if (new TextEncoder().encode(normalizedOwner).byteLength > 256) {
+            throw new IncidentLifecycleError("incident_invalid_filter", 400, "owner is too long");
+        }
+    }
+    const unowned = boolFilter(url.searchParams.get("unowned"), "unowned");
+    const overdue = boolFilter(url.searchParams.get("overdue"), "overdue");
+    const observedAfterClose = boolFilter(url.searchParams.get("observedAfterClose"), "observedAfterClose");
+    return {
+        ...(state === null ? {} : { state: state }),
+        ...(owner === null ? {} : { owner: owner.trim() }),
+        ...(unowned === undefined ? {} : { unowned }),
+        ...(overdue === undefined ? {} : { overdue }),
+        ...(observedAfterClose === undefined ? {} : { observedAfterClose }),
+    };
+}
+function incidentIdentityFromPath(pathname) {
+    const encoded = pathname.slice("/maintenance/incidents/".length);
+    if (encoded.length === 0 || encoded.includes("/")) {
+        throw new IncidentLifecycleError("incident_route_not_found", 404, "Incident route not found");
+    }
+    try {
+        return normalizeIncidentIdentity(decodeURIComponent(encoded));
+    }
+    catch {
+        throw new IncidentLifecycleError("incident_invalid_request", 400, "Incident identity must be URI encoded");
+    }
+}
+export function isIncidentMaintenancePath(pathname) {
+    return pathname === "/maintenance/incidents" || pathname.startsWith("/maintenance/incidents/");
+}
+export async function handleIncidentMaintenance(request, env, serviceIdentityProvider) {
+    const token = configuredToken(env.INCIDENT_MAINTAINER_TOKEN);
+    if (token === undefined) {
+        return error(503, "incident_maintenance_unavailable", "Incident maintenance is not configured");
+    }
+    if (!(await authenticated(request, token))) {
+        return error(401, "incident_auth_required", "A valid incident maintenance bearer token is required");
+    }
+    let serviceId;
+    try {
+        serviceId = requestServiceIdentity(request, serviceIdentityProvider, {
+            allowG11Verification: env.G11_VERIFICATION_ENABLED === "true",
+        });
+    }
+    catch {
+        return error(503, "scope.identity_missing", "A deployment service identity is required for this scope");
+    }
+    if (env.D1 === undefined) {
+        return error(503, "incident_maintenance_unavailable", "Incident maintenance storage is unavailable");
+    }
+    const lifecycle = new IncidentLifecycle(env.D1);
+    const url = new URL(request.url);
+    try {
+        if (request.method === "GET" && url.pathname === "/maintenance/incidents") {
+            return json(await lifecycle.list(serviceId, parseFilters(url)));
+        }
+        if (request.method === "GET" && url.pathname.startsWith("/maintenance/incidents/")) {
+            return json(await lifecycle.detail(serviceId, incidentIdentityFromPath(url.pathname)));
+        }
+        if (request.method === "POST" && url.pathname === "/maintenance/incidents/transitions") {
+            let body;
+            try {
+                body = await request.json();
+            }
+            catch {
+                return error(400, "incident_invalid_request", "Transition request must be JSON");
+            }
+            const requestValue = IncidentLifecycle.parseTransition(body);
+            const actor = request.headers.get("x-sdt-maintainer");
+            if (actor === null) {
+                return error(400, "incident_invalid_actor", "x-sdt-maintainer is required");
+            }
+            return json(await lifecycle.transition(serviceId, requestValue, actor));
+        }
+        return error(404, "incident_route_not_found", "Incident maintenance route not found");
+    }
+    catch (caught) {
+        if (caught instanceof IncidentLifecycleError)
+            return error(caught.status, caught.code, caught.message);
+        return error(500, "incident_maintenance_failed", "Incident maintenance could not complete the request");
+    }
+}

package/dist/index.d.ts

@@ -37,6 +37,9 @@ export { downstreamEnvelopeBytes, classifyDirectDoorbellFailure, readDomainDeliv
 export { deliveryCorrelationId } from "./downstream/DeliveryCore";
 export { GlobalCompletenessReconciler } from "./completeness/GlobalCompletenessReconciler";
 export { G44_HEALTH_STALE_AFTER_MS, G44_SCANNER_VERSION, GLOBAL_COMPLETENESS_INTERIM_DISPOSITION, } from "./completeness/types";
+export { IncidentLifecycle, IncidentLifecycleError, normalizeIncidentIdentity, } from "./completeness/IncidentLifecycle";
+export type { IncidentDetailResult, IncidentFinding, IncidentListFilters, IncidentListItem, IncidentListResult, IncidentTransitionResult, } from "./completeness/IncidentLifecycle";
+export type { IncidentCloseResolution, IncidentCorrection, IncidentLifecycleProjection, IncidentLifecycleState, IncidentTransitionRecord, IncidentTransitionRequest, } from "./completeness/types";
 export type { GlobalCompletenessHealth, GlobalCompletenessHealthRecord, GlobalCompletenessScanResult, SourceObligationFact, SourceObligationPage, SourcePartitionSnapshot, } from "./completeness/types";
 export { assertCanonicalEventType, canonicalEventType, DeliveryIdentityError, MissingCanonicalEventIdentityError, resolveDeliveryIdentity, } from "./eventIdentity";
 export type { DeliveryProvenance, EventProvenance, ResolvedDeliveryIdentity } from "./eventIdentity";
@@ -44,6 +47,8 @@ export { allocateOrderRange, diagnosticAllocatedAt, decodeOrderOrdinal, encodeOr
 export type { OrderAllocationRange, OrderClock } from "./allocator/OrderClock";
 export { DOTNET_MAX_TICKS, DOTNET_TICKS_PER_MILLISECOND, DOTNET_UNIX_EPOCH_TICKS, MAX_UNIX_MILLISECONDS, SORTABLE_UNIQUE_ID_DIGITS, SORTABLE_UNIQUE_ID_RANDOM_DIGITS, SORTABLE_UNIQUE_ID_TICKS_DIGITS, SortableUniqueIdError, assertDotNetTicks, assertSortableUniqueId, compareSortableUniqueId, cryptoRandomSortableUniqueIdSuffix, dotNetTicksToUnixMs, formatSortableUniqueId, isSortableUniqueId, observeLegacySortableUniqueIdDecision, unixMsToDotNetTicks, } from "./allocator/SortableUniqueId";
 export type { ParsedSortableUniqueId, SortableUniqueIdErrorCode } from "./allocator/SortableUniqueId";
+export { admitActiveWrite, assertNoSilentLedgerMerge, assertStrictlyBefore, createRotationState, maxSortableUniqueId, recordLateArrival, refuseSafeWindowSeal, refuseSealedWrite, refuseSilentLedgerMerge, replaceSealedIdentity, rotateAppend, ShardRotationError, } from "./shard/ShardRotation";
+export type { LateArrival, SealedShard, ShardRotationDiagnostic, ShardRotationState, } from "./shard/ShardRotation";
 export { MAX_PUBLISHED_SAFE_WINDOW_MS, PUBLISHED_SAFE_WINDOW_MS, safeWindowCeilingExceeded, safeWindowCutoffSuid, safeWindowMs, } from "./safeWindow";
 export { SERIALIZED_COMMIT_CORRELATION_ID, SERIALIZED_SEKIBAN_EXECUTOR, createUuidV7, isRfc4122Uuid, isUuidV7, serializedEventMetadata, writeTimestampUtc, } from "./eventRecord";
 export type { SerializedEventMetadata } from "./eventRecord";
@@ -64,6 +69,7 @@ export interface Env {
     TAG_STATE: DurableObjectNamespace;
     /** Secret binding; deployment must configure this rather than a public var. */
     REPAIR_OPERATOR_TOKEN: string;
+    INCIDENT_MAINTAINER_TOKEN?: string;
     /** Queue producer/consumer for durable Tag outbox rows. */
     DOWNSTREAM_QUEUE: Queue<DownstreamOutboxMessage>;
     DOWNSTREAM_DOORBELL?: DownstreamDoorbellBinding;
@@ -72,6 +78,11 @@ export interface Env {
     /** Local Docker/CI connection; deployed Workers normally use HYPERDRIVE. */
     POSTGRES_URL?: string;
     HYPERDRIVE?: Hyperdrive;
+    /** Experimental Cosmos endpoint and database deployment values. */
+    COSMOS_ENDPOINT?: string;
+    COSMOS_DATABASE?: string;
+    /** Experimental Cosmos account key; configure it as a Worker secret. */
+    COSMOS_KEY?: string;
     REPAIR_EXCLUSION_LOOKUP?: Fetcher;
     /** Only an authenticated deployment-verification lane may set this. */
     G11_VERIFICATION_ENABLED?: string;