@rex0220/ksql-flownet 1.0.0

package/dist/persistence/kintone/repository.js

@@ -0,0 +1,836 @@
+import { createHash } from "node:crypto";
+import { attemptKey, runKey } from "../../domain/canonical-record-key.js";
+import { MAX_KINTONE_UNIQUE_KEY_LENGTH } from "../../domain/canonical-lock-key.js";
+import { RepositoryError } from "../repository.js";
+import { isAllowedNodeStateTransition, isAllowedResolutionTransition, } from "../state-transition.js";
+import { KintoneApiError, KintoneClient, KintoneTransportError, } from "./client.js";
+const field = (value) => ({ value });
+const text = (record, code) => String(record[code]?.value ?? "");
+const nullableText = (record, code) => {
+    const value = text(record, code);
+    return value === "" ? null : value;
+};
+const numberValue = (record, code) => Number(record[code]?.value);
+const nullableNumber = (record, code) => {
+    const value = record[code]?.value;
+    return value === "" || value === null || value === undefined
+        ? null
+        : Number(value);
+};
+const jsonArray = (record, code) => JSON.parse(text(record, code));
+const revisionOf = (record) => Number(record.$revision?.value);
+function quote(value) {
+    return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function inQuery(fieldCode, value) {
+    return `${fieldCode} in (${quote(value)})`;
+}
+async function pagedRecords(client, filter) {
+    const result = [];
+    let lastId = 0;
+    while (true) {
+        const page = await client.getRecords(`${filter} and $id > ${lastId} order by $id asc limit 100`);
+        result.push(...page);
+        if (page.length < 100)
+            return result;
+        const nextId = Number(page.at(-1)?.$id?.value);
+        if (!Number.isSafeInteger(nextId) || nextId <= lastId) {
+            throw new RepositoryError("REMOTE_ERROR", "kintone pagination returned an invalid $id");
+        }
+        lastId = nextId;
+    }
+}
+function resolutionDetails(record) {
+    const raw = text(record, "reason");
+    try {
+        const value = JSON.parse(raw);
+        return {
+            resolution_type: value.resolution_type,
+            reason: String(value.reason ?? ""),
+            stop_confirmed_by: String(value.stop_confirmed_by ?? ""),
+            stop_evidence_ref: String(value.stop_evidence_ref ?? ""),
+            resolved_at: typeof value.resolved_at === "string" ? value.resolved_at : undefined,
+        };
+    }
+    catch {
+        return {
+            resolution_type: "OUTCOME_CONFIRMED",
+            reason: raw,
+            stop_confirmed_by: "",
+            stop_evidence_ref: "",
+        };
+    }
+}
+function uniqueKey(value) {
+    if (value.length > MAX_KINTONE_UNIQUE_KEY_LENGTH) {
+        throw new RepositoryError("UNIQUE_KEY_TOO_LONG", `unique key exceeds ${MAX_KINTONE_UNIQUE_KEY_LENGTH} characters`);
+    }
+    return value;
+}
+function resolutionRecordKey(attemptId, resolvedAt) {
+    const digest = createHash("sha256")
+        .update(`${attemptId}\0${resolvedAt}`)
+        .digest("hex");
+    return `RES:${digest.slice(0, MAX_KINTONE_UNIQUE_KEY_LENGTH - 4)}`;
+}
+function decodeResolution(value) {
+    const details = resolutionDetails(value);
+    return {
+        event_type: text(value, "event_type"),
+        ...details,
+        attempt_id: text(value, "attempt_id"),
+        resolved_outcome: text(value, "resolved_outcome"),
+        evidence_ref: text(value, "evidence_ref"),
+        service_principal: text(value, "service_principal"),
+        requested_by: text(value, "requested_by"),
+        approved_by: text(value, "approved_by"),
+        resolved_at: details.resolved_at ?? text(value, "resolved_at"),
+    };
+}
+function mapError(error) {
+    if (error instanceof KintoneApiError) {
+        if (error.status === 409 && error.apiCode === "GAIA_CO02") {
+            throw new RepositoryError("REVISION_CONFLICT", error.message, error);
+        }
+        if (error.status === 400 && error.apiCode === "CB_VA01") {
+            throw new RepositoryError("DUPLICATE_RECORD", error.message, error);
+        }
+    }
+    if (error instanceof KintoneTransportError) {
+        throw new RepositoryError("AMBIGUOUS_WRITE", error.message, error);
+    }
+    throw new RepositoryError("REMOTE_ERROR", "kintone operation failed", error);
+}
+function versioned(record, decode) {
+    return { value: decode(record), revision: revisionOf(record) };
+}
+function runRecord(run) {
+    return {
+        record_key: field(uniqueKey(runRecordKey(run))),
+        record_type: field("NETWORK_RUN"),
+        run_id: field(run.run_id),
+        network_id: field(run.network_id),
+        business_key: field(run.business_key),
+        max_active_runs: field(run.max_active_runs),
+        status: field(run.status),
+        lifecycle_status: field(run.lifecycle_status),
+        resume_allowed: field(String(run.resume_allowed)),
+        as_of: field(run.as_of ?? ""),
+        definition_schema_version: field(run.definition_schema_version),
+        definition_sha256: field(run.definition_sha256),
+        source_bundle_sha256: field(run.source_bundle_sha256),
+        // The schema stores an attachment, whose upload fileKey is supplied here.
+        // Bundle upload/filename reconciliation belongs to FN-07/M4.
+        source_bundle_attachment: field([
+            { fileKey: run.source_bundle_attachment },
+        ]),
+        resolved_profile_snapshot: field(JSON.stringify(run.resolved_profile_snapshot)),
+        resolved_profile_sha256: field(run.resolved_profile_sha256),
+        ksql_flow_version: field(run.ksql_flow_version),
+        engine_version: field(run.engine_version),
+        dialect: field(run.dialect),
+        created_at: field(run.created_at),
+        started_at: field(run.started_at ?? ""),
+        finished_at: field(run.finished_at ?? ""),
+        updated_at: field(run.updated_at),
+    };
+}
+function runRecordKey(run) {
+    return runKey(run.resolved_profile_snapshot.profile, run.network_id, run.business_key);
+}
+function decodeRun(record) {
+    const attachments = record.source_bundle_attachment?.value;
+    return {
+        run_id: text(record, "run_id"),
+        network_id: text(record, "network_id"),
+        business_key: text(record, "business_key"),
+        max_active_runs: numberValue(record, "max_active_runs"),
+        status: text(record, "status"),
+        lifecycle_status: text(record, "lifecycle_status"),
+        resume_allowed: text(record, "resume_allowed") === "true",
+        as_of: nullableText(record, "as_of"),
+        definition_schema_version: numberValue(record, "definition_schema_version"),
+        definition_sha256: text(record, "definition_sha256"),
+        source_bundle_sha256: text(record, "source_bundle_sha256"),
+        source_bundle_attachment: attachments?.[0]?.fileKey ?? attachments?.[0]?.name ?? "",
+        resolved_profile_snapshot: JSON.parse(text(record, "resolved_profile_snapshot")),
+        resolved_profile_sha256: text(record, "resolved_profile_sha256"),
+        ksql_flow_version: text(record, "ksql_flow_version"),
+        engine_version: text(record, "engine_version"),
+        dialect: numberValue(record, "dialect"),
+        created_at: text(record, "created_at"),
+        started_at: nullableText(record, "started_at"),
+        finished_at: nullableText(record, "finished_at"),
+        updated_at: text(record, "updated_at"),
+    };
+}
+function cancelRequestRecord(value) {
+    const details = {
+        state: value.state,
+        requested_by: value.requested_by,
+        reason: value.reason,
+        requested_at: value.requested_at,
+        accepted_at: value.accepted_at,
+        released_at: value.released_at,
+        release_reason: value.release_reason,
+        release_requested_by: value.release_requested_by,
+    };
+    return {
+        record_key: field(uniqueKey(`CANCEL:${value.run_id}`)),
+        record_type: field("CANCEL_REQUEST"),
+        run_id: field(value.run_id),
+        status_reason: field(JSON.stringify(details)),
+    };
+}
+function decodeCancelRequest(record) {
+    let details;
+    try {
+        details = JSON.parse(text(record, "status_reason"));
+    }
+    catch (error) {
+        throw new RepositoryError("REMOTE_ERROR", "CANCEL_REQUEST status_reason is not valid JSON", error);
+    }
+    if (details === null ||
+        typeof details !== "object" ||
+        !("state" in details) ||
+        !["REQUESTED", "ACCEPTED", "RELEASED"].includes(String(details.state))) {
+        throw new RepositoryError("REMOTE_ERROR", "CANCEL_REQUEST status_reason has an invalid state");
+    }
+    const value = details;
+    return { run_id: text(record, "run_id"), ...value };
+}
+function allowedCancelTransition(from, to) {
+    return ((from === "REQUESTED" && (to === "ACCEPTED" || to === "RELEASED")) ||
+        (from === "ACCEPTED" && to === "RELEASED") ||
+        (from === "RELEASED" && to === "REQUESTED"));
+}
+function invocationRecord(value) {
+    return {
+        record_key: field(uniqueKey(`INV:${value.invocation_id}`)),
+        record_type: field("RUN_INVOCATION"),
+        run_id: field(value.run_id),
+        started_at: field(value.started_at),
+        finished_at: field(value.finished_at ?? ""),
+        status: field(value.status),
+        result_code: field(value.result_code),
+        invocation_id: field(value.invocation_id),
+        mode: field(value.mode),
+        requested_by: field(value.requested_by),
+        host: field(value.host),
+        selected_node_ids: field(JSON.stringify(value.selected_node_ids)),
+        preserved_node_ids: field(JSON.stringify(value.preserved_node_ids)),
+        blocked_node_ids: field(JSON.stringify(value.blocked_node_ids)),
+        reason: field(value.reason),
+    };
+}
+function decodeInvocation(record) {
+    return {
+        invocation_id: text(record, "invocation_id"),
+        run_id: text(record, "run_id"),
+        mode: text(record, "mode"),
+        requested_by: text(record, "requested_by"),
+        host: text(record, "host"),
+        started_at: text(record, "started_at"),
+        finished_at: nullableText(record, "finished_at"),
+        status: text(record, "status"),
+        result_code: text(record, "result_code"),
+        selected_node_ids: jsonArray(record, "selected_node_ids"),
+        preserved_node_ids: jsonArray(record, "preserved_node_ids"),
+        blocked_node_ids: jsonArray(record, "blocked_node_ids"),
+        reason: text(record, "reason"),
+    };
+}
+function stateRecord(value) {
+    return {
+        record_key: field(uniqueKey(`STATE:${value.node_state_key}`)),
+        record_type: field("NODE_STATE"),
+        run_id: field(value.run_id),
+        revision: field(value.revision),
+        status: field(value.status),
+        started_at: field(value.started_at ?? ""),
+        finished_at: field(value.finished_at ?? ""),
+        updated_at: field(value.updated_at),
+        node_state_id: field(value.node_state_id),
+        node_state_key: field(uniqueKey(value.node_state_key)),
+        node_id: field(value.node_id),
+        job_id: field(value.job_id),
+        latest_attempt_no: field(value.latest_attempt_no),
+        active_attempt_id: field(value.active_attempt_id ?? ""),
+        idempotent: field(String(value.idempotent)),
+        trigger_rule: field(value.trigger_rule),
+        blocked_by: field(JSON.stringify(value.blocked_by)),
+        status_reason: field(value.status_reason ?? ""),
+    };
+}
+function decodeState(record) {
+    return {
+        node_state_id: text(record, "node_state_id"),
+        node_state_key: text(record, "node_state_key"),
+        run_id: text(record, "run_id"),
+        node_id: text(record, "node_id"),
+        job_id: text(record, "job_id"),
+        status: text(record, "status"),
+        latest_attempt_no: numberValue(record, "latest_attempt_no"),
+        active_attempt_id: nullableText(record, "active_attempt_id"),
+        revision: numberValue(record, "revision"),
+        idempotent: text(record, "idempotent") === "true",
+        trigger_rule: text(record, "trigger_rule"),
+        blocked_by: jsonArray(record, "blocked_by"),
+        status_reason: nullableText(record, "status_reason"),
+        started_at: nullableText(record, "started_at"),
+        finished_at: nullableText(record, "finished_at"),
+        updated_at: text(record, "updated_at"),
+    };
+}
+function attemptRecord(value) {
+    return {
+        record_key: field(uniqueKey(`ATT:${value.node_attempt_id}`)),
+        record_type: field("NODE_ATTEMPT"),
+        run_id: field(value.run_id),
+        finished_at: field(value.finished_at ?? ""),
+        status: field(value.status),
+        result_code: field(value.result_code),
+        node_attempt_id: field(uniqueKey(value.node_attempt_id)),
+        attempt_key: field(uniqueKey(value.attempt_key)),
+        node_id: field(value.node_id),
+        job_id: field(value.job_id),
+        invocation_id: field(value.invocation_id),
+        attempt_no: field(value.attempt_no),
+        execution_started_at: field(value.execution_started_at ?? ""),
+        runner_execution_started_at: field(value.runner_execution_started_at ?? ""),
+        execution_id: field(value.execution_id ?? ""),
+        duration_sec: field(value.duration_sec ?? ""),
+        error_message: field(value.error_message ?? ""),
+        read_count: field(value.read_count),
+        written_count: field(value.written_count),
+        last_successful_chunk_no: field(value.last_successful_chunk_no ?? ""),
+        last_written_key: field(value.last_written_key ?? ""),
+        state_revision_before: field(value.state_revision_before ?? ""),
+    };
+}
+function decodeAttempt(record) {
+    return {
+        node_attempt_id: text(record, "node_attempt_id"),
+        attempt_key: text(record, "attempt_key"),
+        run_id: text(record, "run_id"),
+        node_id: text(record, "node_id"),
+        job_id: text(record, "job_id"),
+        invocation_id: text(record, "invocation_id"),
+        attempt_no: numberValue(record, "attempt_no"),
+        status: text(record, "status"),
+        result_code: text(record, "result_code"),
+        execution_started_at: nullableText(record, "execution_started_at"),
+        runner_execution_started_at: nullableText(record, "runner_execution_started_at"),
+        execution_id: nullableText(record, "execution_id"),
+        finished_at: nullableText(record, "finished_at"),
+        duration_sec: nullableNumber(record, "duration_sec"),
+        error_message: nullableText(record, "error_message"),
+        read_count: numberValue(record, "read_count"),
+        written_count: numberValue(record, "written_count"),
+        last_successful_chunk_no: nullableNumber(record, "last_successful_chunk_no"),
+        last_written_key: nullableText(record, "last_written_key"),
+        state_revision_before: nullableNumber(record, "state_revision_before"),
+    };
+}
+export class KintonePersistenceRepository {
+    state;
+    audit;
+    constructor(config) {
+        this.state = new KintoneClient({
+            baseUrl: config.baseUrl,
+            appId: config.stateAppId,
+            apiToken: config.stateApiToken,
+            ...(config.fetch ? { fetch: config.fetch } : {}),
+        });
+        this.audit = new KintoneClient({
+            baseUrl: config.baseUrl,
+            appId: config.auditAppId,
+            apiToken: config.auditApiToken,
+            ...(config.fetch ? { fetch: config.fetch } : {}),
+        });
+    }
+    async createRun(run) {
+        const recordKey = runRecordKey(run);
+        return this.createWithAdjudication(this.state, recordKey, runRecord(run), decodeRun, (found) => found.run_id === run.run_id);
+    }
+    async getCancelRequest(runId) {
+        try {
+            const records = await this.state.getRecords(inQuery("record_key", `CANCEL:${runId}`));
+            if (records.length === 0)
+                return null;
+            if (records.length !== 1)
+                throw new RepositoryError("MULTIPLE_RECORDS", `cancel request for run_id ${runId} is not unique`);
+            return versioned(records[0], decodeCancelRequest);
+        }
+        catch (error) {
+            if (error instanceof RepositoryError)
+                throw error;
+            mapError(error);
+        }
+    }
+    async createCancelRequest(request) {
+        if (request.state !== "REQUESTED")
+            throw new RepositoryError("INVALID_STATE_TRANSITION", "a new cancel request must be REQUESTED");
+        return this.createWithAdjudication(this.state, `CANCEL:${request.run_id}`, cancelRequestRecord(request), decodeCancelRequest, (found) => found.run_id === request.run_id);
+    }
+    async updateCancelRequest(runId, expectedRevision, request) {
+        const key = `CANCEL:${runId}`;
+        const current = await this.requiredByRecordKey(this.state, key, decodeCancelRequest);
+        if (request.run_id !== runId ||
+            !allowedCancelTransition(current.value.state, request.state))
+            throw new RepositoryError("INVALID_STATE_TRANSITION", `${current.value.state} -> ${request.state} is not allowed`);
+        await this.put(this.state, key, expectedRevision, {
+            status_reason: cancelRequestRecord(request).status_reason,
+        });
+        return { value: request, revision: expectedRevision + 1 };
+    }
+    async getRunByBusinessKey(profile, networkId, businessKey) {
+        const recordKey = runKey(profile, networkId, businessKey);
+        let records;
+        try {
+            records = await this.state.getRecords(inQuery("record_key", recordKey));
+        }
+        catch (error) {
+            mapError(error);
+        }
+        if (records.length === 0)
+            return null;
+        if (records.length !== 1) {
+            throw new RepositoryError("MULTIPLE_RECORDS", "multiple runs matched");
+        }
+        const found = versioned(records[0], decodeRun);
+        if (runRecordKey(found.value) !== recordKey) {
+            throw new RepositoryError("REMOTE_ERROR", "run fields do not match canonical record key");
+        }
+        return found;
+    }
+    async getRun(runId) {
+        return this.requiredRunById(runId);
+    }
+    async listRuns(profile, networkId) {
+        let records;
+        try {
+            records = await pagedRecords(this.state, `${inQuery("record_type", "NETWORK_RUN")} and ${inQuery("network_id", networkId)}`);
+        }
+        catch (error) {
+            mapError(error);
+        }
+        return records
+            .map((record) => versioned(record, decodeRun))
+            .filter(({ value }) => value.resolved_profile_snapshot.profile === profile)
+            .sort((left, right) => left.value.run_id.localeCompare(right.value.run_id));
+    }
+    async updateRunAggregate(runId, expectedRevision, update) {
+        const current = await this.requiredRunById(runId);
+        const recordKey = runRecordKey(current.value);
+        const value = { ...current.value, ...update };
+        await this.put(this.state, recordKey, expectedRevision, {
+            status: field(update.status),
+            started_at: field(update.started_at ?? ""),
+            finished_at: field(update.finished_at ?? ""),
+            updated_at: field(update.updated_at),
+        });
+        return { value, revision: expectedRevision + 1 };
+    }
+    async archiveRun(runId, expectedRevision, at) {
+        const current = await this.requiredRunById(runId);
+        const recordKey = runRecordKey(current.value);
+        await this.put(this.state, recordKey, expectedRevision, {
+            lifecycle_status: field("ARCHIVED"),
+            updated_at: field(at),
+        });
+        return {
+            value: { ...current.value, lifecycle_status: "ARCHIVED", updated_at: at },
+            revision: expectedRevision + 1,
+        };
+    }
+    async requiredRunById(runId) {
+        let records;
+        try {
+            records = await this.state.getRecords([inQuery("record_type", "NETWORK_RUN"), inQuery("run_id", runId)].join(" and "));
+        }
+        catch (error) {
+            mapError(error);
+        }
+        if (records.length === 0)
+            throw new RepositoryError("RECORD_NOT_FOUND", `run ${runId} not found`);
+        if (records.length !== 1)
+            throw new RepositoryError("MULTIPLE_RECORDS", `run_id ${runId} is not unique`);
+        return versioned(records[0], decodeRun);
+    }
+    async createInvocation(value) {
+        return this.createWithAdjudication(this.audit, `INV:${value.invocation_id}`, invocationRecord(value), decodeInvocation, (found) => found.invocation_id === value.invocation_id);
+    }
+    async getInvocations(runId) {
+        let records;
+        try {
+            records = await pagedRecords(this.audit, `${inQuery("record_type", "RUN_INVOCATION")} and ${inQuery("run_id", runId)}`);
+        }
+        catch (error) {
+            mapError(error);
+        }
+        // kintone DATETIMEは分精度のため、順序は$id(pagedRecordsの取得順)で保持する
+        return records.map((record) => versioned(record, decodeInvocation));
+    }
+    async finalizeInvocation(invocationId, expectedRevision, finalization) {
+        const key = `INV:${invocationId}`;
+        const current = await this.requiredByRecordKey(this.audit, key, decodeInvocation);
+        const currentStatus = current.value.status;
+        if (currentStatus !== "RUNNING" && currentStatus !== "CREATED") {
+            throw new RepositoryError("INVALID_STATE_TRANSITION", "only an unterminated invocation can be finalized");
+        }
+        await this.put(this.audit, key, expectedRevision, {
+            status: field(finalization.status),
+            result_code: field(finalization.result_code),
+            finished_at: field(finalization.finished_at),
+            ...(finalization.selected_node_ids === undefined
+                ? {}
+                : {
+                    selected_node_ids: field(JSON.stringify(finalization.selected_node_ids)),
+                }),
+            ...(finalization.preserved_node_ids === undefined
+                ? {}
+                : {
+                    preserved_node_ids: field(JSON.stringify(finalization.preserved_node_ids)),
+                }),
+            ...(finalization.blocked_node_ids === undefined
+                ? {}
+                : {
+                    blocked_node_ids: field(JSON.stringify(finalization.blocked_node_ids)),
+                }),
+            ...(finalization.reason === undefined
+                ? {}
+                : { reason: field(finalization.reason) }),
+        });
+        return {
+            value: {
+                ...current.value,
+                status: finalization.status,
+                result_code: finalization.result_code,
+                finished_at: finalization.finished_at,
+                selected_node_ids: finalization.selected_node_ids === undefined
+                    ? current.value.selected_node_ids
+                    : [...finalization.selected_node_ids],
+                preserved_node_ids: finalization.preserved_node_ids === undefined
+                    ? current.value.preserved_node_ids
+                    : [...finalization.preserved_node_ids],
+                blocked_node_ids: finalization.blocked_node_ids === undefined
+                    ? current.value.blocked_node_ids
+                    : [...finalization.blocked_node_ids],
+                reason: finalization.reason ?? current.value.reason,
+            },
+            revision: expectedRevision + 1,
+        };
+    }
+    async getNodeStates(runId) {
+        const records = await this.state.getRecords(`${inQuery("record_type", "NODE_STATE")} and ${inQuery("run_id", runId)}`);
+        return records.map((record) => versioned(record, decodeState));
+    }
+    async getAttempts(runId) {
+        const records = await this.audit.getRecords(`${inQuery("record_type", "NODE_ATTEMPT")} and ${inQuery("run_id", runId)}`);
+        return records.map((record) => versioned(record, decodeAttempt));
+    }
+    async getResolutions(runId) {
+        const attemptIds = new Set((await this.getAttempts(runId)).map(({ value }) => value.node_attempt_id));
+        const records = await this.audit.getRecords(inQuery("record_type", "ATTEMPT_RESOLUTION"));
+        return records
+            .filter((record) => attemptIds.has(text(record, "attempt_id")))
+            .map((record) => versioned(record, decodeResolution));
+    }
+    async upsertNodeState(write) {
+        const key = `STATE:${write.value.node_state_key}`;
+        if (write.expected_revision === null) {
+            if (write.value.status !== "WAITING") {
+                throw new RepositoryError("INVALID_STATE_TRANSITION", "a new node state must be WAITING");
+            }
+            return this.createWithAdjudication(this.state, key, stateRecord(write.value), decodeState, (found) => found.node_state_key === write.value.node_state_key);
+        }
+        const current = await this.requiredByRecordKey(this.state, key, decodeState);
+        if (write.resolution_event !== undefined) {
+            const resolution = await this.requiredByRecordKey(this.audit, resolutionRecordKey(write.resolution_event.attempt_id, write.resolution_event.resolved_at), decodeResolution);
+            if (resolution.value.event_type !== write.resolution_event.event_type ||
+                resolution.value.attempt_id !== write.resolution_event.attempt_id ||
+                resolution.value.resolved_outcome !==
+                    write.resolution_event.resolved_outcome ||
+                resolution.value.resolved_at !== write.resolution_event.resolved_at) {
+                throw new RepositoryError("RECORD_NOT_FOUND", "the correlated Attempt Resolution does not match");
+            }
+        }
+        const resolutionTransition = write.resolution_event !== undefined &&
+            write.resolution_event.resolved_outcome === write.value.status &&
+            isAllowedResolutionTransition(current.value.status, write.value.status);
+        if (!isAllowedNodeStateTransition(current.value.status, write.value.status) &&
+            !resolutionTransition) {
+            throw new RepositoryError("INVALID_STATE_TRANSITION", `${current.value.status} -> ${write.value.status} is not allowed`);
+        }
+        if ((current.value.status === "FAILED" ||
+            current.value.status === "CANCELLED") &&
+            write.value.status === "WAITING" &&
+            !current.value.idempotent) {
+            throw new RepositoryError("INVALID_STATE_TRANSITION", "a non-idempotent node cannot resume automatically");
+        }
+        const newRevision = write.expected_revision + 1;
+        const value = { ...write.value, revision: newRevision };
+        await this.put(this.state, key, write.expected_revision, stateRecord(value));
+        return { value, revision: newRevision };
+    }
+    async createAttempt(input) {
+        const state = input.node_state.value;
+        const attemptNo = state.latest_attempt_no + 1;
+        const value = {
+            node_attempt_id: input.node_attempt_id,
+            attempt_key: attemptKey(state.run_id, state.node_id, attemptNo),
+            run_id: state.run_id,
+            node_id: state.node_id,
+            job_id: state.job_id,
+            invocation_id: input.invocation_id,
+            attempt_no: attemptNo,
+            status: "RUNNING",
+            result_code: "PENDING",
+            execution_started_at: null,
+            runner_execution_started_at: null,
+            execution_id: null,
+            finished_at: null,
+            duration_sec: null,
+            error_message: null,
+            read_count: 0,
+            written_count: 0,
+            last_successful_chunk_no: null,
+            last_written_key: null,
+            state_revision_before: input.node_state.revision,
+        };
+        try {
+            return await this.createWithAdjudication(this.audit, `ATT:${value.node_attempt_id}`, attemptRecord(value), decodeAttempt, (found) => found.node_attempt_id === value.node_attempt_id);
+        }
+        catch (error) {
+            if (error instanceof RepositoryError &&
+                (error.code === "DUPLICATE_RECORD" || error.code === "AMBIGUOUS_WRITE")) {
+                const matches = await this.audit.getRecords(`${inQuery("record_type", "NODE_ATTEMPT")} and ${inQuery("attempt_key", value.attempt_key)}`);
+                if (matches.length === 1 &&
+                    text(matches[0], "node_attempt_id") === value.node_attempt_id) {
+                    return versioned(matches[0], decodeAttempt);
+                }
+                throw new RepositoryError("ATTEMPT_NUMBER_CONFLICT", `attempt number ${attemptNo} cannot be uniquely confirmed`, error);
+            }
+            throw error;
+        }
+    }
+    async setAttemptExecutionStarted(attemptId, expectedRevision, start) {
+        const key = `ATT:${attemptId}`;
+        const current = await this.requiredByRecordKey(this.audit, key, decodeAttempt);
+        if (current.value.status !== "RUNNING")
+            throw new RepositoryError("ATTEMPT_TERMINAL", "attempt is terminal");
+        if (current.value.execution_started_at !== null)
+            throw new RepositoryError("ATTEMPT_LIFECYCLE_VIOLATION", "execution_started_at is already set");
+        await this.put(this.audit, key, expectedRevision, {
+            execution_started_at: field(start.execution_started_at),
+        });
+        return {
+            value: { ...current.value, ...start },
+            revision: expectedRevision + 1,
+        };
+    }
+    async setAttemptInputBaseline(attemptId, expectedRevision, write) {
+        const key = `ATT:${attemptId}`;
+        const current = await this.requiredByRecordKey(this.audit, key, decodeAttempt);
+        if (current.value.status !== "RUNNING" ||
+            current.value.execution_started_at !== null)
+            throw new RepositoryError("ATTEMPT_LIFECYCLE_VIOLATION", "input baseline must be recorded before execution starts");
+        await this.put(this.audit, key, expectedRevision, {
+            error_message: field(write.error_message),
+        });
+        return {
+            value: { ...current.value, error_message: write.error_message },
+            revision: expectedRevision + 1,
+        };
+    }
+    async finalizeAttempt(attemptId, expectedRevision, finalization) {
+        const key = `ATT:${attemptId}`;
+        const current = await this.requiredByRecordKey(this.audit, key, decodeAttempt);
+        if (current.value.status !== "RUNNING")
+            throw new RepositoryError("ATTEMPT_TERMINAL", "attempt is terminal");
+        const value = { ...current.value, ...finalization };
+        await this.put(this.audit, key, expectedRevision, attemptRecord(value));
+        return { value, revision: expectedRevision + 1 };
+    }
+    async appendResolution(value) {
+        const attempt = await this.requiredByRecordKey(this.audit, `ATT:${value.attempt_id}`, decodeAttempt);
+        if (attempt.value.status !== "UNKNOWN" && attempt.value.status !== "FAILED")
+            throw new RepositoryError("ATTEMPT_LIFECYCLE_VIOLATION", "only UNKNOWN or FAILED attempts can be resolved");
+        const key = resolutionRecordKey(value.attempt_id, value.resolved_at);
+        const record = {
+            record_key: field(key),
+            record_type: field("ATTEMPT_RESOLUTION"),
+            event_type: field(value.event_type),
+            attempt_id: field(value.attempt_id),
+            resolved_outcome: field(value.resolved_outcome),
+            evidence_ref: field(value.evidence_ref),
+            service_principal: field(value.service_principal),
+            requested_by: field(value.requested_by),
+            approved_by: field(value.approved_by),
+            reason: field(JSON.stringify({
+                resolution_type: value.resolution_type,
+                reason: value.reason,
+                stop_confirmed_by: value.stop_confirmed_by,
+                stop_evidence_ref: value.stop_evidence_ref,
+                resolved_at: value.resolved_at,
+            })),
+            resolved_at: field(value.resolved_at),
+        };
+        return this.createWithAdjudication(this.audit, key, record, () => value, () => true);
+    }
+    async appendOperationAudit(value) {
+        const key = uniqueKey(`OP:${value.event_id}`);
+        const networkForceRelease = value.event_type === "NETWORK_LOCK_FORCE_RELEASED";
+        const archived = value.event_type === "RUN_ARCHIVED";
+        const record = {
+            record_key: field(key),
+            record_type: field("OPERATION_AUDIT"),
+            run_id: field(networkForceRelease ? "" : value.run_id),
+            result_code: field(value.event_type === "RECONCILIATION_REPAIR"
+                ? value.repair_type
+                : value.event_type === "JOB_LOCK_FORCE_UNLOCK_RECORDED"
+                    ? value.lock_recovery_result.outcome
+                    : value.event_type),
+            reason: field(JSON.stringify(value)),
+            resolved_at: field(value.event_type === "RECONCILIATION_REPAIR"
+                ? value.occurred_at
+                : value.event_type === "JOB_LOCK_FORCE_UNLOCK_RECORDED"
+                    ? value.recorded_at
+                    : archived
+                        ? value.archived_at
+                        : value.released_at),
+        };
+        return this.createWithAdjudication(this.audit, key, record, (found) => JSON.parse(text(found, "reason")), (found) => found.event_id === value.event_id &&
+            (!archived ||
+                (found.event_type === "RUN_ARCHIVED" &&
+                    found.run_id === value.run_id &&
+                    found.previous_status === value.previous_status &&
+                    found.run_revision_before === value.run_revision_before)), archived ? "AUDIT_CONFLICT" : undefined);
+    }
+    async getOperationAuditByEventId(eventId) {
+        const key = uniqueKey(`OP:${eventId}`);
+        let records;
+        try {
+            records = await this.audit.getRecords(inQuery("record_key", key));
+        }
+        catch (error) {
+            mapError(error);
+        }
+        if (records.length === 0)
+            return null;
+        if (records.length !== 1)
+            throw new RepositoryError("MULTIPLE_RECORDS", "multiple operation audits matched");
+        return versioned(records[0], (record) => JSON.parse(text(record, "reason")));
+    }
+    async listInconsistencies(runId) {
+        const states = await this.getNodeStates(runId);
+        const attemptRecords = await this.audit.getRecords(`${inQuery("record_type", "NODE_ATTEMPT")} and ${inQuery("run_id", runId)}`);
+        const attempts = attemptRecords.map((record) => versioned(record, decodeAttempt));
+        const result = [];
+        for (const state of states) {
+            const nodeAttempts = attempts.filter(({ value }) => value.node_id === state.value.node_id);
+            const running = nodeAttempts.filter(({ value }) => value.status === "RUNNING");
+            if (running.length > 1)
+                result.push({
+                    code: "MULTIPLE_RUNNING_ATTEMPTS",
+                    node_state: state,
+                    attempts: running,
+                });
+            if (state.value.active_attempt_id) {
+                const active = nodeAttempts.find(({ value }) => value.node_attempt_id === state.value.active_attempt_id);
+                if (!active)
+                    result.push({ code: "ACTIVE_ATTEMPT_MISSING", node_state: state });
+                else if (active.value.status !== state.value.status)
+                    result.push({
+                        code: "STATE_ATTEMPT_STATUS_MISMATCH",
+                        node_state: state,
+                        attempt: active,
+                    });
+            }
+        }
+        return result;
+    }
+    async createWithAdjudication(client, recordKey, record, decode, same, mismatchCode) {
+        try {
+            const created = await client.postRecord(record);
+            return {
+                value: decode({
+                    ...record,
+                    $revision: field(String(created.revision)),
+                }),
+                revision: created.revision,
+            };
+        }
+        catch (error) {
+            if (!(error instanceof KintoneTransportError) &&
+                !(error instanceof KintoneApiError &&
+                    error.status === 400 &&
+                    error.apiCode === "CB_VA01"))
+                mapError(error);
+            let records;
+            try {
+                records = await client.getRecords(inQuery("record_key", recordKey));
+            }
+            catch (rereadError) {
+                mapError(rereadError);
+            }
+            if (records.length === 1) {
+                const found = versioned(records[0], decode);
+                if (same(found.value))
+                    return found;
+                if (mismatchCode !== undefined)
+                    throw new RepositoryError(mismatchCode, "operation audit event_id belongs to different archive facts", error);
+            }
+            if (error instanceof KintoneTransportError)
+                throw new RepositoryError("AMBIGUOUS_WRITE", "insert cannot be uniquely confirmed", error);
+            throw new RepositoryError("DUPLICATE_RECORD", "insert unique conflict belongs to another record", error);
+        }
+    }
+    async requiredByRecordKey(client, recordKey, decode) {
+        let records;
+        try {
+            records = await client.getRecords(inQuery("record_key", recordKey));
+        }
+        catch (error) {
+            mapError(error);
+        }
+        if (records.length === 0)
+            throw new RepositoryError("RECORD_NOT_FOUND", `${recordKey} not found`);
+        if (records.length !== 1)
+            throw new RepositoryError("MULTIPLE_RECORDS", `${recordKey} is not unique`);
+        return versioned(records[0], decode);
+    }
+    async put(client, recordKey, revision, record) {
+        try {
+            // TODO(FDR): define a retry policy. Until then, deliberately do not retry;
+            // callers must re-GET and reconcile ambiguous outcomes before continuing.
+            const update = { ...record };
+            delete update.record_key;
+            await client.putRecord(recordKey, revision, update);
+        }
+        catch (error) {
+            if (error instanceof KintoneApiError &&
+                error.status === 400 &&
+                error.apiCode === "GAIA_DA02") {
+                // A concurrent updateKey PUT loser can be reported as GAIA_DA02 rather
+                // than GAIA_CO02. Only reclassify it when a re-GET proves that the
+                // expected revision lost its target; otherwise retain fail-closed
+                // REMOTE_ERROR behavior for unrelated GAIA_DA02 responses.
+                let records;
+                try {
+                    records = await client.getRecords(inQuery("record_key", recordKey));
+                }
+                catch {
+                    mapError(error);
+                }
+                if (records.length === 0 ||
+                    (records.length === 1 && revisionOf(records[0]) > revision)) {
+                    throw new RepositoryError("REVISION_CONFLICT", error.message, error);
+                }
+            }
+            mapError(error);
+        }
+    }
+}
+//# sourceMappingURL=repository.js.map