@rex0220/ksql-flownet 1.0.0

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

@@ -0,0 +1,116 @@
+export declare const KINTONE_FIELD_MAP: {
+    readonly NETWORK_RUN: {
+        readonly record_key: "record_key";
+        readonly record_type: "record_type";
+        readonly run_id: "run_id";
+        readonly network_id: "network_id";
+        readonly business_key: "business_key";
+        readonly max_active_runs: "max_active_runs";
+        readonly status: "status";
+        readonly lifecycle_status: "lifecycle_status";
+        readonly resume_allowed: "resume_allowed";
+        readonly as_of: "as_of";
+        readonly definition_schema_version: "definition_schema_version";
+        readonly definition_sha256: "definition_sha256";
+        readonly source_bundle_sha256: "source_bundle_sha256";
+        readonly source_bundle_attachment: "source_bundle_attachment";
+        readonly resolved_profile_snapshot: "resolved_profile_snapshot";
+        readonly resolved_profile_sha256: "resolved_profile_sha256";
+        readonly ksql_flow_version: "ksql_flow_version";
+        readonly engine_version: "engine_version";
+        readonly dialect: "dialect";
+        readonly created_at: "created_at";
+        readonly started_at: "started_at";
+        readonly finished_at: "finished_at";
+        readonly updated_at: "updated_at";
+    };
+    readonly NODE_STATE: {
+        readonly record_key: "record_key";
+        readonly record_type: "record_type";
+        readonly run_id: "run_id";
+        readonly revision: "revision";
+        readonly status: "status";
+        readonly started_at: "started_at";
+        readonly finished_at: "finished_at";
+        readonly updated_at: "updated_at";
+        readonly node_state_id: "node_state_id";
+        readonly node_state_key: "node_state_key";
+        readonly node_id: "node_id";
+        readonly job_id: "job_id";
+        readonly latest_attempt_no: "latest_attempt_no";
+        readonly active_attempt_id: "active_attempt_id";
+        readonly idempotent: "idempotent";
+        readonly trigger_rule: "trigger_rule";
+        readonly blocked_by: "blocked_by";
+        readonly status_reason: "status_reason";
+    };
+    readonly CANCEL_REQUEST: {
+        readonly record_key: "record_key";
+        readonly record_type: "record_type";
+        readonly run_id: "run_id";
+        readonly status_reason: "status_reason";
+    };
+    readonly RUN_INVOCATION: {
+        readonly record_key: "record_key";
+        readonly record_type: "record_type";
+        readonly run_id: "run_id";
+        readonly started_at: "started_at";
+        readonly finished_at: "finished_at";
+        readonly status: "status";
+        readonly result_code: "result_code";
+        readonly invocation_id: "invocation_id";
+        readonly mode: "mode";
+        readonly requested_by: "requested_by";
+        readonly host: "host";
+        readonly selected_node_ids: "selected_node_ids";
+        readonly preserved_node_ids: "preserved_node_ids";
+        readonly blocked_node_ids: "blocked_node_ids";
+        readonly reason: "reason";
+    };
+    readonly NODE_ATTEMPT: {
+        readonly record_key: "record_key";
+        readonly record_type: "record_type";
+        readonly run_id: "run_id";
+        readonly finished_at: "finished_at";
+        readonly status: "status";
+        readonly result_code: "result_code";
+        readonly node_attempt_id: "node_attempt_id";
+        readonly attempt_key: "attempt_key";
+        readonly node_id: "node_id";
+        readonly job_id: "job_id";
+        readonly invocation_id: "invocation_id";
+        readonly attempt_no: "attempt_no";
+        readonly execution_started_at: "execution_started_at";
+        readonly runner_execution_started_at: "runner_execution_started_at";
+        readonly execution_id: "execution_id";
+        readonly duration_sec: "duration_sec";
+        readonly error_message: "error_message";
+        readonly read_count: "read_count";
+        readonly written_count: "written_count";
+        readonly last_successful_chunk_no: "last_successful_chunk_no";
+        readonly last_written_key: "last_written_key";
+        readonly state_revision_before: "state_revision_before";
+    };
+    readonly ATTEMPT_RESOLUTION: {
+        readonly record_key: "record_key";
+        readonly record_type: "record_type";
+        readonly event_type: "event_type";
+        readonly attempt_id: "attempt_id";
+        readonly resolved_outcome: "resolved_outcome";
+        readonly evidence_ref: "evidence_ref";
+        readonly service_principal: "service_principal";
+        readonly requested_by: "requested_by";
+        readonly approved_by: "approved_by";
+        readonly resolved_at: "resolved_at";
+    };
+    readonly OPERATION_AUDIT: {
+        readonly record_key: "record_key";
+        readonly record_type: "record_type";
+        readonly run_id: "run_id";
+        readonly result_code: "result_code";
+        readonly reason: "reason";
+        readonly resolved_at: "resolved_at";
+    };
+};
+export type KintoneRecordType = keyof typeof KINTONE_FIELD_MAP;
+//# sourceMappingURL=schema.d.ts.map

package/dist/persistence/kintone/schema.js

@@ -0,0 +1,115 @@
+export const KINTONE_FIELD_MAP = {
+    NETWORK_RUN: {
+        record_key: "record_key",
+        record_type: "record_type",
+        run_id: "run_id",
+        network_id: "network_id",
+        business_key: "business_key",
+        max_active_runs: "max_active_runs",
+        status: "status",
+        lifecycle_status: "lifecycle_status",
+        resume_allowed: "resume_allowed",
+        as_of: "as_of",
+        definition_schema_version: "definition_schema_version",
+        definition_sha256: "definition_sha256",
+        source_bundle_sha256: "source_bundle_sha256",
+        source_bundle_attachment: "source_bundle_attachment",
+        resolved_profile_snapshot: "resolved_profile_snapshot",
+        resolved_profile_sha256: "resolved_profile_sha256",
+        ksql_flow_version: "ksql_flow_version",
+        engine_version: "engine_version",
+        dialect: "dialect",
+        created_at: "created_at",
+        started_at: "started_at",
+        finished_at: "finished_at",
+        updated_at: "updated_at",
+    },
+    NODE_STATE: {
+        record_key: "record_key",
+        record_type: "record_type",
+        run_id: "run_id",
+        revision: "revision",
+        status: "status",
+        started_at: "started_at",
+        finished_at: "finished_at",
+        updated_at: "updated_at",
+        node_state_id: "node_state_id",
+        node_state_key: "node_state_key",
+        node_id: "node_id",
+        job_id: "job_id",
+        latest_attempt_no: "latest_attempt_no",
+        active_attempt_id: "active_attempt_id",
+        idempotent: "idempotent",
+        trigger_rule: "trigger_rule",
+        blocked_by: "blocked_by",
+        status_reason: "status_reason",
+    },
+    CANCEL_REQUEST: {
+        record_key: "record_key",
+        record_type: "record_type",
+        run_id: "run_id",
+        status_reason: "status_reason",
+    },
+    RUN_INVOCATION: {
+        record_key: "record_key",
+        record_type: "record_type",
+        run_id: "run_id",
+        started_at: "started_at",
+        finished_at: "finished_at",
+        status: "status",
+        result_code: "result_code",
+        invocation_id: "invocation_id",
+        mode: "mode",
+        requested_by: "requested_by",
+        host: "host",
+        selected_node_ids: "selected_node_ids",
+        preserved_node_ids: "preserved_node_ids",
+        blocked_node_ids: "blocked_node_ids",
+        reason: "reason",
+    },
+    NODE_ATTEMPT: {
+        record_key: "record_key",
+        record_type: "record_type",
+        run_id: "run_id",
+        finished_at: "finished_at",
+        status: "status",
+        result_code: "result_code",
+        node_attempt_id: "node_attempt_id",
+        attempt_key: "attempt_key",
+        node_id: "node_id",
+        job_id: "job_id",
+        invocation_id: "invocation_id",
+        attempt_no: "attempt_no",
+        execution_started_at: "execution_started_at",
+        runner_execution_started_at: "runner_execution_started_at",
+        execution_id: "execution_id",
+        duration_sec: "duration_sec",
+        error_message: "error_message",
+        read_count: "read_count",
+        written_count: "written_count",
+        last_successful_chunk_no: "last_successful_chunk_no",
+        last_written_key: "last_written_key",
+        state_revision_before: "state_revision_before",
+    },
+    ATTEMPT_RESOLUTION: {
+        record_key: "record_key",
+        record_type: "record_type",
+        event_type: "event_type",
+        attempt_id: "attempt_id",
+        resolved_outcome: "resolved_outcome",
+        evidence_ref: "evidence_ref",
+        service_principal: "service_principal",
+        requested_by: "requested_by",
+        approved_by: "approved_by",
+        resolved_at: "resolved_at",
+    },
+    OPERATION_AUDIT: {
+        record_key: "record_key",
+        record_type: "record_type",
+        run_id: "run_id",
+        result_code: "result_code",
+        reason: "reason",
+        resolved_at: "resolved_at",
+    },
+};
+//# sourceMappingURL=schema.js.map

package/dist/persistence/network-lock-reader.d.ts

@@ -0,0 +1,24 @@
+export interface NetworkLockStatus {
+    readonly record_id: string;
+    readonly owner_invocation_id: string;
+    readonly owner_instance_id: string;
+    readonly heartbeat_at: string;
+    readonly lease_expires_at: string;
+    readonly revision: number;
+}
+export interface NetworkLockStatusReader {
+    getNetworkLock(profile: string, networkId: string): Promise<NetworkLockStatus | null>;
+}
+export interface KintoneNetworkLockStatusReaderConfig {
+    readonly baseUrl: string;
+    readonly stateAppId: number;
+    readonly stateApiToken: string;
+    readonly fetch?: typeof fetch;
+}
+export declare function ownerInstanceIdFromStatusReason(statusReason: string): string;
+export declare class KintoneNetworkLockStatusReader implements NetworkLockStatusReader {
+    private readonly client;
+    constructor(config: KintoneNetworkLockStatusReaderConfig);
+    getNetworkLock(profile: string, networkId: string): Promise<NetworkLockStatus | null>;
+}
+//# sourceMappingURL=network-lock-reader.d.ts.map

package/dist/persistence/network-lock-reader.js

@@ -0,0 +1,43 @@
+import { networkLockKey } from "../domain/canonical-lock-key.js";
+import { KintoneClient } from "./kintone/client.js";
+import { RepositoryError } from "./repository.js";
+const text = (record, code) => String(record[code]?.value ?? "");
+export function ownerInstanceIdFromStatusReason(statusReason) {
+    return statusReason.startsWith("owner_instance_id=")
+        ? statusReason.slice("owner_instance_id=".length)
+        : "";
+}
+function quote(value) {
+    return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+export class KintoneNetworkLockStatusReader {
+    client;
+    constructor(config) {
+        this.client = new KintoneClient({
+            baseUrl: config.baseUrl,
+            appId: config.stateAppId,
+            apiToken: config.stateApiToken,
+            ...(config.fetch === undefined ? {} : { fetch: config.fetch }),
+        });
+    }
+    async getNetworkLock(profile, networkId) {
+        const lockKey = networkLockKey(profile, networkId);
+        const records = await this.client.getRecords(`record_type in ("NETWORK_LOCK") and lock_key in (${quote(lockKey)}) and status in ("RUNNING")`);
+        if (records.length === 0)
+            return null;
+        if (records.length !== 1) {
+            throw new RepositoryError("MULTIPLE_RECORDS", "multiple active Network locks matched");
+        }
+        const record = records[0];
+        const ownerInstanceId = ownerInstanceIdFromStatusReason(text(record, "status_reason"));
+        return {
+            record_id: text(record, "$id"),
+            owner_invocation_id: text(record, "owner_invocation_id"),
+            owner_instance_id: ownerInstanceId,
+            heartbeat_at: text(record, "heartbeat_at"),
+            lease_expires_at: text(record, "lease_expires_at"),
+            revision: Number(record.revision?.value),
+        };
+    }
+}
+//# sourceMappingURL=network-lock-reader.js.map

package/dist/persistence/network-lock-recovery.d.ts

@@ -0,0 +1,66 @@
+import type { NetworkLockForceReleaseOperationAudit } from "../domain/persistence-model.js";
+import type { PersistenceRepository } from "./repository.js";
+export interface StopConfirmationInput {
+    readonly profile: string;
+    readonly networkId: string;
+    readonly expectedOwnerInvocationId: string;
+    readonly ownerInstanceId: string;
+    readonly stopConfirmedBy: string;
+    readonly stopMethod: string;
+    readonly stopEvidenceRef: string;
+}
+export interface StopConfirmationResult {
+    readonly confirmed: boolean;
+    readonly method: string;
+    readonly detail: string;
+}
+export interface StopConfirmation {
+    confirm(input: StopConfirmationInput): Promise<StopConfirmationResult>;
+}
+export declare const manualStopConfirmation: StopConfirmation;
+export interface StopConfirmationDependencies {
+    readonly host?: string;
+    readonly processKill?: (pid: number, signal: 0) => boolean;
+    readonly fetch?: typeof fetch;
+    readonly gcpAccessToken?: string;
+    readonly now?: () => Date;
+}
+export declare function createLocalPidStopConfirmation(dependencies?: StopConfirmationDependencies): StopConfirmation;
+export declare function createCloudRunJobExecutionStopConfirmation(dependencies?: StopConfirmationDependencies): StopConfirmation;
+export declare function defaultStopConfirmations(dependencies?: StopConfirmationDependencies): ReadonlyMap<string, StopConfirmation>;
+export type NetworkLockRecoveryErrorCode = "INVALID_ARGUMENT" | "LOCK_NOT_FOUND" | "LOCK_READ_FAILED" | "OWNER_MISMATCH" | "LEASE_STILL_ACTIVE" | "STOP_NOT_CONFIRMED" | "HEARTBEAT_ADVANCED" | "REVISION_CONFLICT" | "RELEASE_UNCONFIRMED" | "AUDIT_FAILED";
+export declare class NetworkLockRecoveryError extends Error {
+    readonly code: NetworkLockRecoveryErrorCode;
+    readonly causeDetail: unknown;
+    constructor(code: NetworkLockRecoveryErrorCode, message: string, causeDetail?: unknown);
+}
+export interface ForceUnlockNetworkInput {
+    readonly networkId: string;
+    readonly profile: string;
+    readonly expectedOwnerInvocationId: string;
+    readonly reason: string;
+    readonly evidenceRef: string;
+    readonly stopConfirmedBy: string;
+    readonly stopEvidenceRef: string;
+    readonly stopMethod: string;
+    readonly servicePrincipal: string;
+    readonly requestedBy: string;
+}
+export interface NetworkLockRecoveryDependencies {
+    readonly baseUrl: string;
+    readonly stateAppId: number;
+    readonly stateApiToken: string;
+    readonly repository: PersistenceRepository;
+    readonly fetch?: typeof fetch;
+    readonly stopConfirmations?: ReadonlyMap<string, StopConfirmation>;
+    readonly now?: () => Date;
+    readonly uuid?: () => string;
+}
+export interface ForceUnlockNetworkResult {
+    readonly lockKey: string;
+    readonly previousOwnerInvocationId: string;
+    readonly postReleaseRevision: number;
+    readonly audit: NetworkLockForceReleaseOperationAudit;
+}
+export declare function forceUnlockNetwork(input: ForceUnlockNetworkInput, dependencies: NetworkLockRecoveryDependencies): Promise<ForceUnlockNetworkResult>;
+//# sourceMappingURL=network-lock-recovery.d.ts.map