@honua/react 0.0.20-alpha.0

package/core/ogc-processes.js

@@ -0,0 +1,423 @@
+/**
+ * OGC API Processes surface. Process discovery, execution, and async
+ * job tracking. Per the ticket constraint, async executions return an
+ * `IJobRun` (the canonical async-operation surface) rather than an
+ * OGC-specific job type.
+ *
+ * @module
+ */
+import { HonuaJobPollTimeoutError, isJobTerminal } from "../contract/jobs.js";
+import { createOgcMetadataParams, mergeHeaders } from "./wire-shared.js";
+const DEFAULT_POLL_INTERVAL_MS = 1_000;
+/** Top-level OGC API Processes handle. */
+export class HonuaOgcProcesses {
+    client;
+    constructor(options) {
+        this.client = options.client;
+    }
+    async landing(request = {}) {
+        return this.client.getOgcProcessesLanding(request);
+    }
+    async conformance(request = {}) {
+        return this.client.getOgcProcessesConformance(request);
+    }
+    async list(request = {}) {
+        return this.client.listOgcProcesses(request);
+    }
+    async describe(processId, request = {}) {
+        return this.client.getOgcProcess({ ...request, processId });
+    }
+    /**
+     * Submit a process for execution. Always returns an `IJobRun`: honua-server
+     * is async-only (advertises `jobControlOptions: ['async-execute', 'dismiss']`),
+     * so the runner polls for the terminal snapshot regardless of whether
+     * `mode` is `"async"` or `"auto"`.
+     */
+    async execute(request) {
+        const accepted = await this.client.executeOgcProcess(request);
+        return new HonuaOgcProcessJobRun({
+            client: this.client,
+            jobId: accepted.jobID,
+            processId: accepted.processID ?? request.processId,
+            initialStatus: accepted.statusInfo ?? {
+                jobID: accepted.jobID,
+                processID: accepted.processID ?? request.processId,
+                status: accepted.status,
+            },
+        });
+    }
+    /** Adopt an existing job by id (useful when reconnecting after navigation). */
+    job(jobId, options = {}) {
+        return new HonuaOgcProcessJobRun({
+            client: this.client,
+            jobId,
+            processId: options.processId,
+        });
+    }
+}
+/**
+ * `IJobRun` implementation backed by OGC API Processes 1.0 status / result
+ * endpoints. Watchers receive the latest `JobSnapshot` when status,
+ * progress, or terminal result changes; cancel is idempotent and races
+ * the server's `dismissed` response against any concurrent terminal
+ * transition.
+ */
+export class HonuaOgcProcessJobRun {
+    id;
+    type;
+    client;
+    pollIntervalMs;
+    pollFn;
+    currentStatus;
+    currentProgress;
+    terminalSnapshot;
+    terminalPromise;
+    listeners = new Set();
+    constructor(options) {
+        this.client = options.client;
+        this.id = options.jobId;
+        this.type = options.processId ?? options.initialStatus?.processID ?? "unknown";
+        this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        this.pollFn = options.pollFn ?? ((jobId, signal) => options.client.getOgcProcessJob({ jobId, signal }));
+        const initial = options.initialStatus;
+        this.currentStatus = initial?.status ?? "accepted";
+        this.currentProgress = progressFromOgcStatus(initial);
+    }
+    get status() {
+        return this.currentStatus;
+    }
+    get progress() {
+        return this.currentProgress;
+    }
+    async poll() {
+        if (this.terminalSnapshot) {
+            return this.terminalSnapshot;
+        }
+        const ogcStatus = await this.pollFn(this.id);
+        return this.handleOgcStatus(ogcStatus);
+    }
+    watch(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async results(options = {}) {
+        if (!this.terminalPromise) {
+            // Reset the cached promise if the poll loop rejects (abort / deadline /
+            // attempt cap) so a later results() call can retry rather than being
+            // permanently poisoned by a transient cancellation.
+            this.terminalPromise = this.runUntilTerminal(options).catch((error) => {
+                this.terminalPromise = undefined;
+                throw error;
+            });
+        }
+        return this.terminalPromise;
+    }
+    async cancel() {
+        if (this.terminalSnapshot) {
+            return this.currentStatus;
+        }
+        try {
+            const cancelled = await this.client.cancelOgcProcessJob({ jobId: this.id });
+            const snapshot = await this.handleOgcStatus(cancelled);
+            return snapshot.status;
+        }
+        catch (error) {
+            const statusCode = error?.statusCode;
+            // `IJobRun.cancel` is documented as idempotent: when the job is
+            // already gone (404), return the cached status. honua-server uses
+            // 409 for three distinct cases — only the terminal-race case is
+            // benign:
+            //   - "Cannot dismiss completed job" → terminal race; poll for the
+            //     authoritative terminal status and return it.
+            //   - "Dismiss could not be confirmed" → backend dismissal request
+            //     was issued but did not confirm; rethrow so callers can retry.
+            //   - "Cancellation not supported" → backend lacks cancel support;
+            //     rethrow so callers can branch.
+            // Any 409 with an unknown title also rethrows. The terminal-race
+            // branch only swallows the 409 when the follow-up poll reaches a
+            // terminal status; a non-terminal poll or a poll failure means the
+            // "completed job" claim cannot be confirmed and the original 409
+            // is the most honest signal.
+            if (statusCode === 404) {
+                return this.currentStatus;
+            }
+            if (statusCode === 409 && isCompletedJobConflict(error)) {
+                let fresh;
+                try {
+                    fresh = await this.pollFn(this.id);
+                }
+                catch {
+                    // Server claimed the job is in a terminal state but the
+                    // follow-up poll could not confirm it. Surface the original
+                    // 409 instead of letting the poll-side error swallow it.
+                    throw error;
+                }
+                const snapshot = await this.handleOgcStatus(fresh);
+                if (!isJobTerminal(snapshot.status)) {
+                    throw error;
+                }
+                return snapshot.status;
+            }
+            throw error;
+        }
+    }
+    async runUntilTerminal(options = {}) {
+        const { signal } = options;
+        const baseIntervalMs = options.pollIntervalMs ?? this.pollIntervalMs;
+        const maxIntervalMs = options.maxPollIntervalMs ?? Math.max(baseIntervalMs, 30_000);
+        const startedAt = Date.now();
+        let attempts = 0;
+        while (!this.terminalSnapshot) {
+            if (signal?.aborted) {
+                throw new HonuaJobPollTimeoutError(`Job ${this.id} poll aborted`, "aborted", this.id, this.currentStatus);
+            }
+            if (options.maxAttempts !== undefined && attempts >= options.maxAttempts) {
+                throw new HonuaJobPollTimeoutError(`Job ${this.id} did not reach a terminal state within ${options.maxAttempts} poll attempt(s)`, "max-attempts", this.id, this.currentStatus);
+            }
+            let ogcStatus;
+            try {
+                ogcStatus = await this.pollFn(this.id, signal);
+            }
+            catch (error) {
+                if (signal?.aborted) {
+                    throw new HonuaJobPollTimeoutError(`Job ${this.id} poll aborted`, "aborted", this.id, this.currentStatus);
+                }
+                throw error;
+            }
+            attempts += 1;
+            await this.handleOgcStatus(ogcStatus);
+            if (this.terminalSnapshot)
+                break;
+            if (options.deadlineMs !== undefined && Date.now() - startedAt >= options.deadlineMs) {
+                throw new HonuaJobPollTimeoutError(`Job ${this.id} did not reach a terminal state within ${options.deadlineMs}ms`, "deadline", this.id, this.currentStatus);
+            }
+            // Capped exponential backoff instead of a fixed interval.
+            const intervalMs = Math.min(maxIntervalMs, baseIntervalMs * 2 ** (attempts - 1));
+            if (intervalMs > 0) {
+                await delay(intervalMs, signal);
+            }
+        }
+        if (this.terminalSnapshot.status === "successful" && this.terminalSnapshot.result) {
+            return this.terminalSnapshot.result;
+        }
+        throw makeJobFailedError(this.terminalSnapshot);
+    }
+    /**
+     * Translate an OGC `statusInfo` payload onto the canonical snapshot
+     * surface, fire watchers, and (for `successful` terminals) fetch the
+     * result document inline so the snapshot's `result.outputs` is
+     * populated by the time `runUntilTerminal` / `poll` resolves.
+     */
+    async handleOgcStatus(ogcStatus) {
+        const status = ogcStatus.status ?? "accepted";
+        const progress = progressFromOgcStatus(ogcStatus);
+        this.currentStatus = status;
+        this.currentProgress = progress;
+        if (status === "successful") {
+            try {
+                // Per OGC API Processes §7.11.1 the document-mode result body is the
+                // outputs map itself (honua-server returns `{}` for the canonical
+                // V1 process; populated maps are keyed by output id). Wrap it into
+                // the canonical `JobResult.outputs` envelope.
+                const results = await this.client.getOgcProcessJobResults({ jobId: this.id });
+                const snapshot = {
+                    status: "successful",
+                    progress,
+                    result: { outputs: results },
+                };
+                this.terminalSnapshot = snapshot;
+                this.notify(snapshot);
+                return snapshot;
+            }
+            catch (error) {
+                const failure = {
+                    status: "failed",
+                    progress,
+                    error: {
+                        code: error?.name ?? "ResultsFetchFailed",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                };
+                this.currentStatus = "failed";
+                this.terminalSnapshot = failure;
+                this.notify(failure);
+                return failure;
+            }
+        }
+        if (status === "failed" || status === "dismissed") {
+            const error = terminalJobError(status, ogcStatus);
+            const snapshot = {
+                status,
+                progress,
+                ...(error ? { error } : {}),
+            };
+            this.terminalSnapshot = snapshot;
+            this.notify(snapshot);
+            return snapshot;
+        }
+        const snapshot = { status, progress };
+        this.notify(snapshot);
+        return snapshot;
+    }
+    notify(snapshot) {
+        for (const listener of this.listeners) {
+            try {
+                listener(snapshot);
+            }
+            catch {
+                // Listener exceptions must not break the runner; log silently.
+            }
+        }
+    }
+}
+/** Error thrown when `IJobRun.results()` resolves a non-success terminal. */
+export class HonuaJobFailedError extends Error {
+    status;
+    errorCode;
+    details;
+    constructor(message, status, errorCode, details) {
+        super(message);
+        this.name = "HonuaJobFailedError";
+        this.status = status;
+        this.errorCode = errorCode;
+        this.details = details;
+    }
+}
+/**
+ * Honua-server emits problem-details JSON for DELETE /jobs/{id} 409s. The
+ * `title` distinguishes the benign terminal race ("Cannot dismiss
+ * completed job") from non-benign 409s ("Dismiss could not be confirmed",
+ * "Cancellation not supported"). The detail text mirrors the title
+ * ("terminal state '...'") so we accept either as confirmation.
+ */
+function isCompletedJobConflict(error) {
+    const body = error?.body;
+    if (!body || typeof body !== "object")
+        return false;
+    const title = body.title;
+    const detail = body.detail;
+    if (typeof title === "string" && /cannot dismiss completed job/i.test(title)) {
+        return true;
+    }
+    if (typeof detail === "string" && /terminal state/i.test(detail)) {
+        return true;
+    }
+    return false;
+}
+function terminalJobError(status, ogcStatus) {
+    if (ogcStatus.exception) {
+        return { ...ogcStatus.exception };
+    }
+    // honua-server emits failure text as `statusInfo.message` (its
+    // StatusInfo DTO has no `exception` field). Fall back to the progress
+    // message so `HonuaJobFailedError.message` carries the server reason
+    // instead of the generic "non-success terminal state" default.
+    if (typeof ogcStatus.message === "string" && ogcStatus.message.length > 0) {
+        return {
+            code: status === "dismissed" ? "JobDismissed" : "JobFailed",
+            message: ogcStatus.message,
+        };
+    }
+    return undefined;
+}
+function progressFromOgcStatus(ogcStatus) {
+    if (!ogcStatus)
+        return undefined;
+    const out = {};
+    if (typeof ogcStatus.progress === "number" && Number.isFinite(ogcStatus.progress)) {
+        out.percent = clampPercent(ogcStatus.progress);
+    }
+    if (ogcStatus.message !== undefined)
+        out.message = ogcStatus.message;
+    if (ogcStatus.updated !== undefined)
+        out.updatedAt = ogcStatus.updated;
+    if (out.percent === undefined && out.message === undefined && out.updatedAt === undefined) {
+        return undefined;
+    }
+    return out;
+}
+function clampPercent(value) {
+    if (value < 0)
+        return 0;
+    if (value > 100)
+        return 100;
+    return value;
+}
+function makeJobFailedError(snapshot) {
+    const error = snapshot.error;
+    const message = error?.message ?? `Job ended in non-success terminal state: ${snapshot.status}`;
+    return new HonuaJobFailedError(message, snapshot.status, error?.code, error?.details);
+}
+function delay(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve();
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+export function createHonuaOgcProcesses(client) {
+    return new HonuaOgcProcesses({ client });
+}
+// ── OGC API Processes wire methods ──────────────────────────────
+export async function getOgcProcessesLanding(transport, request = {}) {
+    const params = createOgcMetadataParams(request);
+    return transport.requestCachedMetadataJson(`ogc-processes:landing:${params.toString()}`, `/ogc/processes?${params.toString()}`, request);
+}
+export async function getOgcProcessesConformance(transport, request = {}) {
+    const params = createOgcMetadataParams(request);
+    return transport.requestCachedMetadataJson(`ogc-processes:conformance:${params.toString()}`, `/ogc/processes/conformance?${params.toString()}`, request);
+}
+export async function listOgcProcesses(transport, request = {}) {
+    const params = createOgcMetadataParams(request);
+    return transport.requestCachedMetadataJson(`ogc-processes:processes:${params.toString()}`, `/ogc/processes/processes?${params.toString()}`, request);
+}
+export async function getOgcProcess(transport, request) {
+    const params = createOgcMetadataParams(request);
+    return transport.requestCachedMetadataJson(`ogc-processes:process:${request.processId}:${params.toString()}`, `/ogc/processes/processes/${encodeURIComponent(request.processId)}?${params.toString()}`, request);
+}
+export async function executeOgcProcess(transport, request) {
+    const headers = mergeHeaders({ "Content-Type": "application/json", Accept: "application/json" }, request.headers, preferHeaderForExecute(request));
+    const path = `/ogc/processes/processes/${encodeURIComponent(request.processId)}/execution`;
+    // honua-server only supports `response: "document"` and rejects "raw"
+    // with HTTP 501; the SDK pins the supported value here.
+    const body = JSON.stringify({
+        inputs: request.inputs ?? {},
+        outputs: request.outputs,
+        response: "document",
+    });
+    return transport.requestJson("POST", path, { headers, body }, request.signal);
+}
+export async function getOgcProcessJob(transport, request) {
+    const params = createOgcMetadataParams(request);
+    return transport.requestJson("GET", `/ogc/processes/jobs/${encodeURIComponent(request.jobId)}?${params.toString()}`, undefined, request.signal);
+}
+export async function getOgcProcessJobResults(transport, request) {
+    const params = createOgcMetadataParams(request);
+    return transport.requestJson("GET", `/ogc/processes/jobs/${encodeURIComponent(request.jobId)}/results?${params.toString()}`, undefined, request.signal);
+}
+export async function cancelOgcProcessJob(transport, request) {
+    const params = createOgcMetadataParams(request);
+    return transport.requestJson("DELETE", `/ogc/processes/jobs/${encodeURIComponent(request.jobId)}?${params.toString()}`, undefined, request.signal);
+}
+/**
+ * Build the `Prefer` header for an OGC API Processes execution request.
+ * honua-server is async-only: `mode: "async"` sends an explicit
+ * `Prefer: respond-async` so OGC-conformance checkers see the header;
+ * `mode: "auto"` (or unset) omits it and lets the server default apply.
+ */
+function preferHeaderForExecute(request) {
+    if (request.mode === "async") {
+        return { Prefer: "respond-async" };
+    }
+    return undefined;
+}

package/core/ogc-records.d.ts

@@ -0,0 +1,75 @@
+/**
+ * OGC API Records surface. Records are catalog metadata documents about
+ * resources (services, collections, maps, scenes, STAC collections, source
+ * descriptors), not STAC imagery items and not protocol-native service
+ * metadata. The wire calls live on `HonuaClient`; this class is the
+ * request-shaping layer on top.
+ *
+ * @module
+ */
+import type { HonuaClient } from "./client.js";
+import type { HonuaProtocolTransport } from "./protocol-transport.js";
+import type { HonuaOgcCollectionMetadata, HonuaOgcCollectionsResponse, HonuaOgcConformanceResponse, HonuaOgcLandingResponse, HonuaOgcRecordResponse, HonuaOgcRecordsResponse, OgcCollectionRequest, OgcMetadataRequest, OgcRecordItemRequest, OgcRecordRawItemRequest, OgcRecordsRawSearchRequest, OgcRecordsSearchRequest } from "./types.js";
+export interface HonuaOgcRecordsOptions {
+    client: HonuaClient;
+}
+export interface HonuaOgcRecordCollectionOptions {
+    client: HonuaClient;
+    collectionId: string | number;
+}
+export interface HonuaOgcRecordsSearchAllRequest extends OgcRecordsSearchRequest {
+    /** Maximum number of records to request per page. */
+    pageSize?: number;
+    /** Hard cap on the number of pages to fetch (defaults to 100). */
+    maxPages?: number;
+}
+export type HonuaOgcRecordCollectionSearchRequest = Omit<OgcRecordsSearchRequest, "collectionId">;
+export type HonuaOgcRecordCollectionSearchAllRequest = HonuaOgcRecordCollectionSearchRequest & {
+    pageSize?: number;
+    maxPages?: number;
+};
+export type HonuaOgcRecordCollectionItemRequest = Omit<OgcRecordItemRequest, "collectionId">;
+export type HonuaOgcRecordCollectionRawSearchRequest = Omit<OgcRecordsRawSearchRequest, "collectionId">;
+export type HonuaOgcRecordCollectionRawItemRequest = Omit<OgcRecordRawItemRequest, "collectionId">;
+/** Top-level OGC API Records handle. */
+export declare class HonuaOgcRecords {
+    readonly client: HonuaClient;
+    constructor(options: HonuaOgcRecordsOptions);
+    collection(collectionId: string | number): HonuaOgcRecordCollection;
+    landing(request?: OgcMetadataRequest): Promise<HonuaOgcLandingResponse>;
+    conformance(request?: OgcMetadataRequest): Promise<HonuaOgcConformanceResponse>;
+    collections(request?: OgcMetadataRequest): Promise<HonuaOgcCollectionsResponse>;
+    collectionMetadata(request: OgcCollectionRequest): Promise<HonuaOgcCollectionMetadata>;
+    search(request: OgcRecordsSearchRequest): Promise<HonuaOgcRecordsResponse>;
+    record(request: OgcRecordItemRequest): Promise<HonuaOgcRecordResponse>;
+    rawSearch(request: OgcRecordsRawSearchRequest): Promise<Response>;
+    rawRecord(request: OgcRecordRawItemRequest): Promise<Response>;
+    searchAll(request: HonuaOgcRecordsSearchAllRequest): Promise<HonuaOgcRecordResponse[]>;
+    searchStream(request: HonuaOgcRecordsSearchAllRequest): AsyncGenerator<HonuaOgcRecordResponse[], void, undefined>;
+}
+/**
+ * Bound handle for one Records catalog (`/collections/{catalogId}`). Drops
+ * the routing discriminator from per-call requests.
+ */
+export declare class HonuaOgcRecordCollection {
+    readonly client: HonuaClient;
+    readonly collectionId: string | number;
+    constructor(options: HonuaOgcRecordCollectionOptions);
+    metadata(request?: OgcMetadataRequest): Promise<HonuaOgcCollectionMetadata>;
+    search(request?: HonuaOgcRecordCollectionSearchRequest): Promise<HonuaOgcRecordsResponse>;
+    record(request: HonuaOgcRecordCollectionItemRequest): Promise<HonuaOgcRecordResponse>;
+    rawSearch(request?: HonuaOgcRecordCollectionRawSearchRequest): Promise<Response>;
+    rawRecord(request: HonuaOgcRecordCollectionRawItemRequest): Promise<Response>;
+    searchAll(request?: HonuaOgcRecordCollectionSearchAllRequest): Promise<HonuaOgcRecordResponse[]>;
+    searchStream(request?: HonuaOgcRecordCollectionSearchAllRequest): AsyncGenerator<HonuaOgcRecordResponse[], void, undefined>;
+}
+export declare function createHonuaOgcRecords(client: HonuaClient): HonuaOgcRecords;
+export declare function getOgcRecordsLanding(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcLandingResponse>;
+export declare function getOgcRecordsConformance(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcConformanceResponse>;
+export declare function listOgcRecordCollections(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcCollectionsResponse>;
+export declare function getOgcRecordCollection(transport: HonuaProtocolTransport, request: OgcCollectionRequest): Promise<HonuaOgcCollectionMetadata>;
+export declare function searchOgcRecords(transport: HonuaProtocolTransport, request: OgcRecordsSearchRequest): Promise<HonuaOgcRecordsResponse>;
+export declare function getOgcRecord(transport: HonuaProtocolTransport, request: OgcRecordItemRequest): Promise<HonuaOgcRecordResponse>;
+export declare function fetchOgcRecordsRaw(transport: HonuaProtocolTransport, request: OgcRecordsRawSearchRequest): Promise<Response>;
+export declare function fetchOgcRecordRaw(transport: HonuaProtocolTransport, request: OgcRecordRawItemRequest): Promise<Response>;
+//# sourceMappingURL=ogc-records.d.ts.map

package/core/ogc-records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogc-records.d.ts","sourceRoot":"","sources":["../../../src/core/ogc-records.ts"],"names":[],"mappings":"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"}