@sekiban/dcb-runtime 0.2.0 → 0.2.2

package/dist/http/IncidentMaintenance.js

@@ -0,0 +1,124 @@
+import { IncidentLifecycle, IncidentLifecycleError, normalizeIncidentIdentity, } from "../completeness/IncidentLifecycle";
+import { requestServiceIdentity, } from "../service/ServiceIdentityProvider";
+import { checkConfiguredBearer } from "./ConfiguredBearer";
+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 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 decision = await checkConfiguredBearer(request, env.INCIDENT_MAINTAINER_TOKEN, {
+        tokenNormalization: "trim",
+    });
+    if (decision === "unconfigured") {
+        return error(503, "incident_maintenance_unavailable", "Incident maintenance is not configured");
+    }
+    if (decision === "missing" || decision === "invalid") {
+        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/http/SerializedQueryWorker.js

@@ -57,6 +57,39 @@ function parseRequest(value) {
         },
     };
 }
+const QUERY_PARAMS_UNSUPPORTED_MESSAGE = "The selected query does not support these parameters.";
+const LIST_QUERY_PARAM_KEYS = new Set(["PageNumber", "PageSize", "NewestFirst", "consistency"]);
+/**
+ * Scalar queries have no parameter interpreter, so only an empty plain object
+ * is a supported no-parameter call. List queries keep the four existing
+ * controls and leave their value checks to paginationFrom. Non-object list
+ * input is also left to paginationFrom so that validation response stays put.
+ */
+function unsupportedQueryParams(endpoint, queryParams) {
+    if (endpoint === "query") {
+        if (isObject(queryParams) && Object.keys(queryParams).length === 0) {
+            return undefined;
+        }
+        return {
+            status: 400,
+            code: "query_params_unsupported",
+            error: QUERY_PARAMS_UNSUPPORTED_MESSAGE,
+        };
+    }
+    if (!isObject(queryParams)) {
+        return undefined;
+    }
+    for (const key of Object.keys(queryParams)) {
+        if (!LIST_QUERY_PARAM_KEYS.has(key)) {
+            return {
+                status: 400,
+                code: "query_params_unsupported",
+                error: QUERY_PARAMS_UNSUPPORTED_MESSAGE,
+            };
+        }
+    }
+    return undefined;
+}
 function paginationFrom(value) {
     if (!isObject(value)) {
         return { error: "list-query queryParamsJson must contain an object" };
@@ -295,6 +328,10 @@ export async function handleSerializedQuery(request, env, options = {}) {
     if (definition === undefined || definition.endpoint !== endpoint) {
         return error(400, "validation_error", "queryType is not mapped for this endpoint");
     }
+    const unsupported = unsupportedQueryParams(endpoint, parsed.value.queryParams);
+    if (unsupported !== undefined) {
+        return error(unsupported.status, unsupported.code, unsupported.error);
+    }
     if (!definition.enabled || (options.projectors ?? DEPLOYED_PROJECTOR_REGISTRY).resolve(definition.tagProjector) === undefined) {
         return error(503, "projection_unavailable", "The mapped query projection is unavailable");
     }

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,12 +47,16 @@ 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";
 export type { DeliveryCoreEnvironment, DeliveryCoreFailure, DeliveryCoreOptions, DeliveryCoreResult, DeliverySource, DeliveryViewApplyResult, DeliveryViewFailureClass, DeliveryViewHandler, DeliveryViewInput, DeliveryViewResult, } from "./downstream/DeliveryCore";
 export type { DeliveryClass, DirectDoorbellDegradation, DirectDoorbellDeploymentConfig, DirectDoorbellPreflightResult, DirectDoorbellReceiverMode, DirectDoorbellFailureKind, DownstreamDoorbellBinding, } from "./downstream/Doorbell";
 export type { JsonValue, MaterializedViewRowPatch } from "@sekiban/dcb-core";
+export { checkConfiguredBearer } from "./http/ConfiguredBearer";
+export type { CheckConfiguredBearerOptions, ConfiguredBearerResult, ConfiguredBearerTokenNormalization, } from "./http/ConfiguredBearer";
 export { composeRuntime, createRuntimeCommitPort, registeredEventParsers, RuntimeCommandRegistry, } from "./composition";
 export type { RuntimeCommitAllocationLike, RuntimeCommitCandidateLike, RuntimeCommitPort, RuntimeCommitPortOptions, RuntimeCommitPortResult, RuntimeCommandLike, RuntimeDomainLike, RuntimeQueryDefinition, RuntimeWorkerConfig, } from "./composition";
 export { POSTGRES_STORE_PROVIDER, createPostgresBootstrapAdapter, createPostgresStoreProvider } from "./store/provider";
@@ -64,6 +71,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 +80,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;