@rex0220/ksql-flownet 1.0.0

package/dist/orchestration/cancel-request.js

@@ -0,0 +1,67 @@
+import { RepositoryError } from "../persistence/repository.js";
+export class CancelRequestError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "CancelRequestError";
+    }
+}
+const TERMINAL = new Set([
+    "SUCCESS",
+    "FAILED",
+    "CANCELLED",
+    "UNKNOWN",
+]);
+export async function changeCancelRequest(input) {
+    const run = await input.repository.getRun(input.runId);
+    const current = await input.repository.getCancelRequest(input.runId);
+    if (input.release) {
+        if (current === null || current.value.state === "RELEASED")
+            return current;
+        const at = (input.now ?? (() => new Date()))().toISOString();
+        return input.repository.updateCancelRequest(input.runId, current.revision, {
+            ...current.value,
+            state: "RELEASED",
+            released_at: at,
+            release_reason: input.reason,
+            release_requested_by: input.requestedBy,
+        });
+    }
+    if (current?.value.state === "REQUESTED" ||
+        current?.value.state === "ACCEPTED")
+        return current;
+    if (TERMINAL.has(run.value.status))
+        throw new CancelRequestError("RUN_ALREADY_TERMINAL", `run '${input.runId}' is already terminal (${run.value.status})`);
+    const at = (input.now ?? (() => new Date()))().toISOString();
+    const request = {
+        run_id: input.runId,
+        state: "REQUESTED",
+        requested_by: input.requestedBy,
+        reason: input.reason,
+        requested_at: at,
+        accepted_at: null,
+        released_at: null,
+        release_reason: null,
+        release_requested_by: null,
+    };
+    if (current === null) {
+        try {
+            return await input.repository.createCancelRequest(request);
+        }
+        catch (error) {
+            if (!(error instanceof RepositoryError) ||
+                error.code !== "DUPLICATE_RECORD")
+                throw error;
+            const raced = await input.repository.getCancelRequest(input.runId);
+            if (raced === null)
+                throw error;
+            return raced;
+        }
+    }
+    return input.repository.updateCancelRequest(input.runId, current.revision, request);
+}
+export function isCancelHold(request) {
+    return (request?.value.state === "REQUESTED" || request?.value.state === "ACCEPTED");
+}
+//# sourceMappingURL=cancel-request.js.map

package/dist/orchestration/ensure-run.d.ts

@@ -0,0 +1,83 @@
+import type { NetworkDefinition } from "../domain/network-definition.js";
+import type { NetworkRun, RunInvocation, RunInvocationStatus } from "../domain/persistence-model.js";
+import type { CapabilitiesResult, JobInspection, ProfileDescription } from "../executor/ksql-flow-cli.js";
+import type { NetworkLockReference } from "../persistence/network-lock.js";
+import type { PersistenceRepository, Versioned } from "../persistence/repository.js";
+export type EnsureRunOutcome = "NEW" | "RESUME" | "NOOP";
+export type EnsureRunErrorCode = "NETWORK_VALIDATION_FAILED" | "BUSINESS_KEY_INVALID" | "MULTIPLE_RUNS" | "RUN_NOT_FOUND" | "RUN_ALREADY_EXISTS" | "RUN_ID_MISMATCH" | "RUN_NOT_RESUMABLE" | "RUN_ON_HOLD" | "MAX_ACTIVE_RUNS" | "PROFILE_DESCRIPTION_INVALID" | "BUNDLE_INPUT_CHANGED" | "RUN_SNAPSHOT_MISMATCH" | "BUNDLE_DIALECT_MISMATCH" | "RERUN_FROM_SUCCESS_RUN" | "RERUN_FROM_NODE_NOT_FOUND" | "RERUN_FROM_DAG_INVALID" | "RERUN_FROM_UNKNOWN_STATE" | "RERUN_FROM_NON_IDEMPOTENT" | "INPUT_FILE_MUTATED" | "INPUT_RETENTION_EXPIRED" | "ENSURE_RUN_FAILED";
+export declare class EnsureRunError extends Error {
+    readonly code: EnsureRunErrorCode;
+    readonly blockedBy: readonly string[];
+    constructor(code: EnsureRunErrorCode, message: string, blockedBy?: readonly string[], options?: ErrorOptions);
+}
+export interface EnsureRunExecutor {
+    capabilities(): Promise<CapabilitiesResult>;
+    describeProfile(): Promise<ProfileDescription>;
+    inspectJob(sqlPath: string): Promise<JobInspection>;
+}
+export interface EnsureRunBundleStore {
+    upload(zipBytes: Uint8Array): Promise<string>;
+    download(fileKey: string): Promise<Uint8Array>;
+}
+export interface EnsureRunLockManager {
+    acquire(): Promise<NetworkLockReference>;
+    release(reference: NetworkLockReference, status?: string, resultCode?: string): Promise<unknown>;
+}
+export interface EnsureRunInput {
+    readonly networkPath: string;
+    readonly profile: string;
+    readonly scheduledFor?: string;
+    readonly businessKey?: string;
+    readonly resume?: boolean;
+    readonly resumeRunId?: string;
+    readonly rerunFrom?: string;
+    readonly requestedBy: string;
+    readonly host: string;
+    readonly invocationId?: string;
+    readonly repository: PersistenceRepository;
+    readonly lockManager: EnsureRunLockManager;
+    readonly executor: EnsureRunExecutor;
+    readonly bundleStore: EnsureRunBundleStore;
+    readonly beforeLock?: (definition: NetworkDefinition) => {
+        readonly root: string;
+        readonly retentionDays: number;
+    } | void | Promise<{
+        readonly root: string;
+        readonly retentionDays: number;
+    } | void>;
+    readonly ioRoot?: string;
+    readonly ioRetentionDays?: number;
+    readonly now?: () => Date;
+    readonly uuid?: () => string;
+}
+export interface EnsureRunCloseInput {
+    readonly status: Exclude<RunInvocationStatus, "RUNNING">;
+    readonly resultCode: string;
+    readonly selectedNodeIds?: readonly string[];
+    readonly preservedNodeIds?: readonly string[];
+    readonly blockedNodeIds?: readonly string[];
+    readonly reason?: string;
+    /** D-29 unrecovered drain releases only if possible and leaves Invocation untouched. */
+    readonly persistInvocation?: boolean;
+}
+export interface EnsureRunNoopResult {
+    readonly outcome: "NOOP";
+    readonly run: Versioned<NetworkRun>;
+    readonly invocation: null;
+    readonly blockedBy: readonly string[];
+    readonly businessKey: string;
+}
+export interface EnsureRunExecutionResult {
+    readonly outcome: "NEW" | "RESUME";
+    readonly run: Versioned<NetworkRun>;
+    readonly invocation: Versioned<RunInvocation>;
+    readonly blockedBy: readonly string[];
+    readonly businessKey: string;
+    readonly bundleBytes: Buffer;
+    readonly lock: NetworkLockReference;
+    close(input: EnsureRunCloseInput): Promise<void>;
+}
+export type EnsureRunResult = EnsureRunNoopResult | EnsureRunExecutionResult;
+export declare function ensureRun(input: EnsureRunInput): Promise<EnsureRunResult>;
+export declare function profileDescriptionSha256(description: ProfileDescription): string;
+//# sourceMappingURL=ensure-run.d.ts.map