@rex0220/ksql-flownet 1.0.0

package/dist/persistence/kintone/client.js

@@ -0,0 +1,93 @@
+export class KintoneApiError extends Error {
+    status;
+    apiCode;
+    responseBody;
+    constructor(status, apiCode, responseBody) {
+        super(`kintone API returned ${status}${apiCode ? ` ${apiCode}` : ""}`);
+        this.name = "KintoneApiError";
+        this.status = status;
+        this.apiCode = apiCode;
+        this.responseBody = responseBody;
+    }
+}
+export class KintoneTransportError extends Error {
+    causeDetail;
+    constructor(causeDetail) {
+        super("kintone request outcome is unknown");
+        this.name = "KintoneTransportError";
+        this.causeDetail = causeDetail;
+    }
+}
+export class KintoneClient {
+    baseUrl;
+    appId;
+    apiToken;
+    fetchImpl;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.appId = config.appId;
+        this.apiToken = config.apiToken;
+        this.fetchImpl = config.fetch ?? fetch;
+    }
+    async getRecords(query) {
+        const url = new URL(`${this.baseUrl}/k/v1/records.json`);
+        url.searchParams.set("app", String(this.appId));
+        url.searchParams.set("query", query);
+        const body = await this.request("GET", url);
+        return body.records;
+    }
+    async postRecord(record) {
+        const body = await this.request("POST", `${this.baseUrl}/k/v1/record.json`, {
+            app: this.appId,
+            record,
+        });
+        const result = body;
+        return { id: result.id, revision: Number(result.revision) };
+    }
+    async putRecord(recordKey, revision, record) {
+        const body = await this.request("PUT", `${this.baseUrl}/k/v1/record.json`, {
+            app: this.appId,
+            updateKey: { field: "record_key", value: recordKey },
+            revision,
+            record,
+        });
+        return Number(body.revision);
+    }
+    async putRecordById(id, revision, record) {
+        const body = await this.request("PUT", `${this.baseUrl}/k/v1/record.json`, {
+            app: this.appId,
+            id,
+            revision,
+            record,
+        });
+        return Number(body.revision);
+    }
+    async request(method, url, body) {
+        let response;
+        try {
+            response = await this.fetchImpl(url, {
+                method,
+                headers: {
+                    "X-Cybozu-API-Token": this.apiToken,
+                    ...(body === undefined ? {} : { "Content-Type": "application/json" }),
+                },
+                ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            });
+        }
+        catch (error) {
+            throw new KintoneTransportError(error);
+        }
+        const responseBody = await response.json().catch(() => null);
+        if (!response.ok) {
+            const code = typeof responseBody === "object" &&
+                responseBody !== null &&
+                "code" in responseBody &&
+                typeof responseBody.code === "string"
+                ? responseBody.code
+                : null;
+            throw new KintoneApiError(response.status, code, responseBody);
+        }
+        return responseBody;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/persistence/kintone/design-notes.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Durable timestamp precision note (FN-04 / FDR review material):
+ *
+ * kintone DATETIME fields persist minute precision. This affects ordering and
+ * elapsed-time evidence for execution_started_at, runner_execution_started_at,
+ * started_at, finished_at, updated_at, and resolved_at. Domain values remain
+ * ISO-8601 strings and are not redesigned in FN-04. Callers must not use the
+ * persisted DATETIME value to prove sub-minute ordering; precise runner/event
+ * evidence must remain in its owning durable execution log until a later FDR
+ * decision defines a canonical precision-preserving field.
+ */
+export declare const KINTONE_DATETIME_PRECISION: "minute";
+export declare const KINTONE_DATETIME_TRUNCATION_MS = 60000;
+/**
+ * Deployment prerequisite (M3): apply
+ * spikes/a-app-layout/console/add-state-revision-before.console.js to the
+ * selected app layout before integration tests. NODE_ATTEMPT writes formally
+ * include state_revision_before and therefore fail against the old schema.
+ */
+export declare const STATE_REVISION_BEFORE_DEPLOYMENT_REQUIRED: true;
+/**
+ * updateKey concurrency observation (M3 device measurement, 2026-08-30): two
+ * PUTs using the same revision do not have a deterministic loser response.
+ * kintone returned either 409 GAIA_CO02 or 400 GAIA_DA02 across repeated
+ * races. GAIA_DA02 is therefore adjudicated by re-reading the record: a newer
+ * revision or a missing target is a revision conflict, while inconclusive or
+ * failed reads remain fail-closed remote errors.
+ */
+export declare const UPDATE_KEY_DA02_REQUIRES_REREAD: true;
+/**
+ * Network Run uniqueness (M3): the R1 canonical record_key derived from
+ * profile, network_id, and business_key is permanent across terminal and
+ * non-terminal Runs. A duplicate-prohibited INSERT on that key is the final
+ * adjudication. Network-lock serialization only narrows the race window as the
+ * first defense; the unique constraint remains the final defense.
+ */
+export declare const RUN_R1_INSERT_IS_FINAL_UNIQUENESS_ADJUDICATION: true;
+//# sourceMappingURL=design-notes.d.ts.map

package/dist/persistence/kintone/design-notes.js

@@ -0,0 +1,38 @@
+/**
+ * Durable timestamp precision note (FN-04 / FDR review material):
+ *
+ * kintone DATETIME fields persist minute precision. This affects ordering and
+ * elapsed-time evidence for execution_started_at, runner_execution_started_at,
+ * started_at, finished_at, updated_at, and resolved_at. Domain values remain
+ * ISO-8601 strings and are not redesigned in FN-04. Callers must not use the
+ * persisted DATETIME value to prove sub-minute ordering; precise runner/event
+ * evidence must remain in its owning durable execution log until a later FDR
+ * decision defines a canonical precision-preserving field.
+ */
+export const KINTONE_DATETIME_PRECISION = "minute";
+export const KINTONE_DATETIME_TRUNCATION_MS = 60_000;
+/**
+ * Deployment prerequisite (M3): apply
+ * spikes/a-app-layout/console/add-state-revision-before.console.js to the
+ * selected app layout before integration tests. NODE_ATTEMPT writes formally
+ * include state_revision_before and therefore fail against the old schema.
+ */
+export const STATE_REVISION_BEFORE_DEPLOYMENT_REQUIRED = true;
+/**
+ * updateKey concurrency observation (M3 device measurement, 2026-08-30): two
+ * PUTs using the same revision do not have a deterministic loser response.
+ * kintone returned either 409 GAIA_CO02 or 400 GAIA_DA02 across repeated
+ * races. GAIA_DA02 is therefore adjudicated by re-reading the record: a newer
+ * revision or a missing target is a revision conflict, while inconclusive or
+ * failed reads remain fail-closed remote errors.
+ */
+export const UPDATE_KEY_DA02_REQUIRES_REREAD = true;
+/**
+ * Network Run uniqueness (M3): the R1 canonical record_key derived from
+ * profile, network_id, and business_key is permanent across terminal and
+ * non-terminal Runs. A duplicate-prohibited INSERT on that key is the final
+ * adjudication. Network-lock serialization only narrows the race window as the
+ * first defense; the unique constraint remains the final defense.
+ */
+export const RUN_R1_INSERT_IS_FINAL_UNIQUENESS_ADJUDICATION = true;
+//# sourceMappingURL=design-notes.js.map

package/dist/persistence/kintone/repository.d.ts

@@ -0,0 +1,44 @@
+import type { AttemptResolution, CancelRequest, NetworkRun, NodeAttempt, NodeState, OperationAudit, RunInvocation } from "../../domain/persistence-model.js";
+import type { AttemptExecutionStart, AttemptInputBaselineWrite, AttemptFinalization, CreateAttemptInput, Inconsistency, InvocationFinalization, NodeStateWrite, PersistenceRepository, RunAggregateUpdate, Versioned } from "../repository.js";
+export interface KintoneRepositoryConfig {
+    baseUrl: string;
+    stateAppId: number;
+    stateApiToken: string;
+    auditAppId: number;
+    auditApiToken: string;
+    fetch?: typeof fetch;
+}
+export declare class KintonePersistenceRepository implements PersistenceRepository {
+    private readonly state;
+    private readonly audit;
+    constructor(config: KintoneRepositoryConfig);
+    createRun(run: NetworkRun): Promise<Versioned<NetworkRun>>;
+    getCancelRequest(runId: string): Promise<Versioned<CancelRequest> | null>;
+    createCancelRequest(request: CancelRequest): Promise<Versioned<CancelRequest>>;
+    updateCancelRequest(runId: string, expectedRevision: number, request: CancelRequest): Promise<Versioned<CancelRequest>>;
+    getRunByBusinessKey(profile: string, networkId: string, businessKey: string): Promise<Versioned<NetworkRun> | null>;
+    getRun(runId: string): Promise<Versioned<NetworkRun>>;
+    listRuns(profile: string, networkId: string): Promise<Versioned<NetworkRun>[]>;
+    updateRunAggregate(runId: string, expectedRevision: number, update: RunAggregateUpdate): Promise<Versioned<NetworkRun>>;
+    archiveRun(runId: string, expectedRevision: number, at: string): Promise<Versioned<NetworkRun>>;
+    private requiredRunById;
+    createInvocation(value: RunInvocation): Promise<Versioned<RunInvocation>>;
+    getInvocations(runId: string): Promise<Versioned<RunInvocation>[]>;
+    finalizeInvocation(invocationId: string, expectedRevision: number, finalization: InvocationFinalization): Promise<Versioned<RunInvocation>>;
+    getNodeStates(runId: string): Promise<Versioned<NodeState>[]>;
+    getAttempts(runId: string): Promise<Versioned<NodeAttempt>[]>;
+    getResolutions(runId: string): Promise<Versioned<AttemptResolution>[]>;
+    upsertNodeState(write: NodeStateWrite): Promise<Versioned<NodeState>>;
+    createAttempt(input: CreateAttemptInput): Promise<Versioned<NodeAttempt>>;
+    setAttemptExecutionStarted(attemptId: string, expectedRevision: number, start: AttemptExecutionStart): Promise<Versioned<NodeAttempt>>;
+    setAttemptInputBaseline(attemptId: string, expectedRevision: number, write: AttemptInputBaselineWrite): Promise<Versioned<NodeAttempt>>;
+    finalizeAttempt(attemptId: string, expectedRevision: number, finalization: AttemptFinalization): Promise<Versioned<NodeAttempt>>;
+    appendResolution(value: AttemptResolution): Promise<Versioned<AttemptResolution>>;
+    appendOperationAudit(value: OperationAudit): Promise<Versioned<OperationAudit>>;
+    getOperationAuditByEventId(eventId: string): Promise<Versioned<OperationAudit> | null>;
+    listInconsistencies(runId: string): Promise<Inconsistency[]>;
+    private createWithAdjudication;
+    private requiredByRecordKey;
+    private put;
+}
+//# sourceMappingURL=repository.d.ts.map