@honua/app-platform 0.0.20-alpha.0

package/core/stac-static.js

@@ -0,0 +1,195 @@
+/**
+ * Static STAC catalog reader.
+ *
+ * A large share of public STAC catalogs are not API servers — they are
+ * static `catalog.json` / `collection.json` / item trees served from object
+ * storage, with no `/search` endpoint. This reader walks such a tree the
+ * spec-driven way: it follows `rel="child"` links to descend catalogs /
+ * collections and `rel="item"` links to reach STAC Items, resolving every
+ * href against the document it was found in (STAC best-practice relative
+ * links). Filtering (`collections` / `bbox` / `datetime` / `limit`) is
+ * applied client-side and the result is projected onto the same
+ * {@link HonuaStacItemCollectionResponse} envelope the STAC API search path
+ * returns, so the canonical `Source` surface is identical across both
+ * layouts.
+ *
+ * @module
+ */
+import { HonuaCapabilityNotSupportedError } from "./errors.js";
+/** Guardrails so a malformed / cyclic catalog cannot fan out unbounded. */
+const MAX_DOCUMENTS = 500;
+const DEFAULT_ITEM_CAP = 1000;
+/**
+ * Reader bound to the URL of a static STAC catalog / collection root. The
+ * URL is the client baseUrl (the transport resolves same-origin absolute
+ * child/item hrefs directly), so `rootUrl` is normally `""` (the baseUrl
+ * itself) but may be an absolute `catalog.json` URL.
+ */
+export class HonuaStacStaticCatalog {
+    client;
+    rootUrl;
+    constructor(client, rootUrl = "") {
+        this.client = client;
+        this.rootUrl = rootUrl;
+    }
+    /**
+     * Traverse the catalog tree, collect matching items, and return them in
+     * the STAC search envelope shape.
+     */
+    async search(params = {}) {
+        const items = await this.collectItems(params);
+        const filtered = items.filter((item) => matchesFilters(item, params));
+        const cap = typeof params.limit === "number" && params.limit >= 0 ? params.limit : filtered.length;
+        const sliced = filtered.slice(0, cap);
+        return {
+            type: "FeatureCollection",
+            features: sliced,
+            numberReturned: sliced.length,
+            numberMatched: filtered.length,
+            links: [],
+        };
+    }
+    async fetchDoc(url, signal) {
+        // An empty seed root means "the client baseUrl is the catalog document".
+        const path = url === "" ? this.client.serverBaseUrl : url;
+        return this.client.pipelineRequestJson("GET", path, undefined, signal);
+    }
+    /**
+     * Breadth-first walk collecting item documents. Descends `rel="child"`
+     * links; a `collections` filter prunes Collection subtrees whose `id`
+     * is not requested. Bounded by {@link MAX_DOCUMENTS} and the item cap.
+     */
+    async collectItems(params) {
+        const itemCap = typeof params.limit === "number" && params.limit >= 0 ? Math.max(params.limit, 1) : DEFAULT_ITEM_CAP;
+        const wantedCollections = params.collections ? new Set(params.collections) : undefined;
+        const visited = new Set();
+        const queue = [this.rootUrl];
+        const itemUrls = [];
+        let docCount = 0;
+        while (queue.length > 0 && docCount < MAX_DOCUMENTS) {
+            const url = queue.shift();
+            if (url === undefined || visited.has(url))
+                continue;
+            visited.add(url);
+            docCount += 1;
+            let doc;
+            try {
+                doc = await this.fetchDoc(url, params.signal);
+            }
+            catch (err) {
+                if (url === this.rootUrl) {
+                    throw new HonuaCapabilityNotSupportedError("query", "stac", `static catalog root ${url || "(baseUrl)"} could not be read: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                continue;
+            }
+            // A Collection subtree not in the requested set is pruned entirely.
+            if (wantedCollections &&
+                doc.type === "Collection" &&
+                typeof doc.id === "string" &&
+                !wantedCollections.has(doc.id)) {
+                continue;
+            }
+            const base = absoluteBaseFor(url, this.client.serverBaseUrl);
+            for (const link of doc.links ?? []) {
+                if (typeof link.href !== "string")
+                    continue;
+                const rel = (link.rel ?? "").toLowerCase();
+                const resolved = resolveHref(link.href, base);
+                if (rel === "child") {
+                    if (!visited.has(resolved))
+                        queue.push(resolved);
+                }
+                else if (rel === "item" || rel === "items") {
+                    itemUrls.push(resolved);
+                }
+            }
+        }
+        const items = [];
+        for (const itemUrl of itemUrls) {
+            if (items.length >= itemCap)
+                break;
+            try {
+                const item = (await this.fetchDoc(itemUrl, params.signal));
+                if (item && item.type === "Feature")
+                    items.push(item);
+            }
+            catch {
+                // Skip an unreadable item; the traversal is best-effort per item.
+            }
+        }
+        return items;
+    }
+}
+/**
+ * The base URL a document's relative links resolve against. When the reader
+ * was seeded with a bare `""` root (the client baseUrl IS the catalog), use
+ * the client's server base URL so `./child.json` resolves correctly.
+ */
+function absoluteBaseFor(docUrl, serverBaseUrl) {
+    if (docUrl === "")
+        return serverBaseUrl;
+    if (/^https?:\/\//i.test(docUrl))
+        return docUrl;
+    const root = serverBaseUrl.endsWith("/") ? serverBaseUrl : `${serverBaseUrl}/`;
+    try {
+        return new URL(docUrl, root).toString();
+    }
+    catch {
+        return serverBaseUrl;
+    }
+}
+function resolveHref(href, base) {
+    if (/^https?:\/\//i.test(href))
+        return href;
+    try {
+        return new URL(href, base).toString();
+    }
+    catch {
+        return href;
+    }
+}
+function matchesFilters(item, params) {
+    const doc = item;
+    if (params.collections && params.collections.length > 0) {
+        if (typeof doc.collection !== "string" || !params.collections.includes(doc.collection))
+            return false;
+    }
+    if (params.bbox && Array.isArray(doc.bbox) && doc.bbox.length >= 4) {
+        if (!bboxIntersects(params.bbox, doc.bbox))
+            return false;
+    }
+    if (params.datetime) {
+        if (!datetimeMatches(params.datetime, doc))
+            return false;
+    }
+    return true;
+}
+function bboxIntersects(a, b) {
+    // 2D envelope intersection; ignores any z components.
+    const [axmin, aymin, axmax, aymax] = a;
+    const bxmin = b[0];
+    const bymin = b[1];
+    // A 4- or 6-tuple bbox: max x/y are the second half.
+    const bxmax = b.length >= 6 ? b[3] : b[2];
+    const bymax = b.length >= 6 ? b[4] : b[3];
+    return axmin <= bxmax && axmax >= bxmin && aymin <= bymax && aymax >= bymin;
+}
+function datetimeMatches(query, doc) {
+    const dt = doc.properties?.datetime;
+    // Closed / open interval query per STAC (`start/end`, `../end`, `start/..`).
+    if (query.includes("/")) {
+        const [rawStart, rawEnd] = query.split("/");
+        const start = rawStart && rawStart !== ".." ? Date.parse(rawStart) : Number.NEGATIVE_INFINITY;
+        const end = rawEnd && rawEnd !== ".." ? Date.parse(rawEnd) : Number.POSITIVE_INFINITY;
+        const startProp = doc.properties?.start_datetime ?? dt;
+        const endProp = doc.properties?.end_datetime ?? dt;
+        if (!startProp && !endProp)
+            return false;
+        const itemStart = startProp ? Date.parse(startProp) : Number.NEGATIVE_INFINITY;
+        const itemEnd = endProp ? Date.parse(endProp) : Number.POSITIVE_INFINITY;
+        return itemStart <= end && itemEnd >= start;
+    }
+    if (!dt)
+        return false;
+    return Date.parse(dt) === Date.parse(query);
+}

package/core/stac.d.ts

@@ -0,0 +1,67 @@
+/**
+ * STAC API search surface. STAC builds on OGC API Features, so this
+ * class wraps the STAC catalog landing, collections listing, items, and
+ * cross-collection search endpoints. 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, HonuaStacItemCollectionResponse, HonuaStacItemResponse, HonuaStacLandingResponse, OgcCollectionRequest, OgcMetadataRequest, StacSearchRequest } from "./types.js";
+export interface HonuaStacSearchOptions {
+    client: HonuaClient;
+    /**
+     * Path prefix the STAC endpoints are mounted under. Defaults to `/stac`
+     * (Honua facade). Pass `""` for a raw STAC API root (e.g. Earth Search
+     * served at `.../v1`), so the search / collection paths resolve directly
+     * under the client baseUrl.
+     */
+    basePath?: string;
+}
+export interface HonuaStacSearchAllRequest extends StacSearchRequest {
+    /** Maximum number of items to materialize across pages. */
+    pageSize?: number;
+    /** Hard cap on the number of pages to fetch (defaults to 100). */
+    maxPages?: number;
+}
+/**
+ * STAC API entry point. Discovery (`landing`, `collections`,
+ * `collection`) plus search (`search`, `searchAll`, `searchStream`) and
+ * item fetch.
+ */
+export declare class HonuaStacSearch {
+    readonly client: HonuaClient;
+    private readonly basePath;
+    constructor(options: HonuaStacSearchOptions);
+    /** Inject the configured STAC base path unless the caller already set one. */
+    private withBase;
+    landing(request?: OgcMetadataRequest): Promise<HonuaStacLandingResponse>;
+    collections(request?: OgcMetadataRequest): Promise<HonuaOgcCollectionsResponse>;
+    collection(request: OgcCollectionRequest): Promise<HonuaOgcCollectionMetadata>;
+    item(request: {
+        collectionId: string | number;
+        itemId: string | number;
+        signal?: AbortSignal;
+        responseFormat?: string;
+        extraParams?: Record<string, string | number | boolean>;
+        stacBasePath?: string;
+    }): Promise<HonuaStacItemResponse>;
+    search(request?: StacSearchRequest): Promise<HonuaStacItemCollectionResponse>;
+    searchAll(request?: HonuaStacSearchAllRequest): Promise<HonuaStacItemResponse[]>;
+    searchStream(request?: HonuaStacSearchAllRequest): AsyncGenerator<HonuaStacItemResponse[], void, undefined>;
+}
+export declare function createHonuaStacSearch(client: HonuaClient): HonuaStacSearch;
+export declare function getStacLanding(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaStacLandingResponse>;
+export declare function listStacCollections(transport: HonuaProtocolTransport, request?: OgcMetadataRequest): Promise<HonuaOgcCollectionsResponse>;
+export declare function getStacCollection(transport: HonuaProtocolTransport, request: OgcCollectionRequest): Promise<HonuaOgcCollectionMetadata>;
+export declare function getStacItem(transport: HonuaProtocolTransport, request: {
+    collectionId: string | number;
+    itemId: string | number;
+    signal?: AbortSignal;
+    responseFormat?: string;
+    extraParams?: Record<string, string | number | boolean>;
+    stacBasePath?: string;
+}): Promise<HonuaStacItemResponse>;
+export declare function searchStac(transport: HonuaProtocolTransport, request?: StacSearchRequest): Promise<HonuaStacItemCollectionResponse>;
+//# sourceMappingURL=stac.d.ts.map

package/core/stac.d.ts.map

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

package/core/stac.js

@@ -0,0 +1,259 @@
+/**
+ * STAC API search surface. STAC builds on OGC API Features, so this
+ * class wraps the STAC catalog landing, collections listing, items, and
+ * cross-collection search endpoints. The wire calls live on
+ * `HonuaClient`; this class is the request-shaping layer on top.
+ *
+ * @module
+ */
+import { createOgcMetadataParams, mergeHeaders } from "./wire-shared.js";
+const DEFAULT_STAC_PAGE_SIZE = 100;
+const DEFAULT_STAC_MAX_PAGES = 100;
+/**
+ * STAC API entry point. Discovery (`landing`, `collections`,
+ * `collection`) plus search (`search`, `searchAll`, `searchStream`) and
+ * item fetch.
+ */
+export class HonuaStacSearch {
+    client;
+    basePath;
+    constructor(options) {
+        this.client = options.client;
+        this.basePath = options.basePath;
+    }
+    /** Inject the configured STAC base path unless the caller already set one. */
+    withBase(request) {
+        if (this.basePath === undefined || request.stacBasePath !== undefined)
+            return request;
+        return { ...request, stacBasePath: this.basePath };
+    }
+    async landing(request = {}) {
+        return this.client.getStacLanding(this.withBase(request));
+    }
+    async collections(request = {}) {
+        return this.client.listStacCollections(this.withBase(request));
+    }
+    async collection(request) {
+        return this.client.getStacCollection(this.withBase(request));
+    }
+    async item(request) {
+        return this.client.getStacItem(this.withBase(request));
+    }
+    async search(request = {}) {
+        return this.client.searchStac(this.withBase(request));
+    }
+    async searchAll(request = {}) {
+        const pageSize = request.pageSize ?? request.limit ?? DEFAULT_STAC_PAGE_SIZE;
+        const maxPages = request.maxPages ?? DEFAULT_STAC_MAX_PAGES;
+        const items = [];
+        let cursor = { offset: request.offset, next: request.next };
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.client.searchStac(this.withBase({
+                ...request,
+                limit: pageSize,
+                offset: cursor.offset,
+                next: cursor.next,
+            }));
+            const pageItems = response.features ?? [];
+            if (pageItems.length === 0)
+                break;
+            items.push(...pageItems);
+            cursor = nextStacCursor(response.links);
+            // Continuation is driven solely by the next-link cursor (and the
+            // maxPages cap). STAC permits a server to return fewer than `limit`
+            // items on a non-final page while still advertising a `rel=next` link,
+            // so a short page must not stop paging.
+            if (cursor.offset === undefined && cursor.next === undefined)
+                break;
+        }
+        return items;
+    }
+    async *searchStream(request = {}) {
+        const pageSize = request.pageSize ?? request.limit ?? DEFAULT_STAC_PAGE_SIZE;
+        const maxPages = request.maxPages ?? DEFAULT_STAC_MAX_PAGES;
+        let cursor = { offset: request.offset, next: request.next };
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.client.searchStac(this.withBase({
+                ...request,
+                limit: pageSize,
+                offset: cursor.offset,
+                next: cursor.next,
+            }));
+            const pageItems = response.features ?? [];
+            if (pageItems.length === 0)
+                break;
+            yield pageItems;
+            cursor = nextStacCursor(response.links);
+            // See searchAll: a short page is not a termination signal; rely on the
+            // next-link cursor and the maxPages cap.
+            if (cursor.offset === undefined && cursor.next === undefined)
+                break;
+        }
+    }
+}
+/**
+ * Resolve the next-page cursor for STAC paging. honua-server emits a
+ * `rel=next` link with `?offset=N` on the href; some non-Honua STAC
+ * servers emit `?next=…` opaque tokens instead. Prefer `offset` when the
+ * link carries it, otherwise fall back to `next`. When the server omits
+ * a usable `rel=next` link, return an empty cursor so the caller stops.
+ */
+function nextStacCursor(links) {
+    if (!links)
+        return {};
+    for (const link of links) {
+        if (link.rel !== "next" || typeof link.href !== "string")
+            continue;
+        try {
+            const url = new URL(link.href, "https://placeholder.test");
+            const offsetParam = url.searchParams.get("offset");
+            if (offsetParam !== null) {
+                const offset = Number(offsetParam);
+                if (Number.isFinite(offset))
+                    return { offset };
+            }
+            const nextParam = url.searchParams.get("next");
+            if (nextParam !== null)
+                return { next: nextParam };
+        }
+        catch {
+            // ignore unparsable hrefs; keep scanning for a usable link
+        }
+    }
+    return {};
+}
+export function createHonuaStacSearch(client) {
+    return new HonuaStacSearch({ client });
+}
+// ── STAC API wire methods ───────────────────────────────────────
+/**
+ * Path prefix the STAC endpoints are mounted under. Defaults to `/stac`
+ * (the Honua Server facade). Backend-agnostic callers pointing at a raw
+ * STAC API root pass `""` so the paths resolve directly under the client
+ * baseUrl (e.g. Earth Search served at `.../v1`).
+ */
+function stacBase(request) {
+    const base = request.stacBasePath;
+    if (base === undefined)
+        return "/stac";
+    // Trim trailing slashes; an explicit "" means "the client baseUrl is the
+    // STAC API root".
+    let end = base.length;
+    while (end > 0 && base.charCodeAt(end - 1) === 0x2f)
+        end--;
+    return base.slice(0, end);
+}
+export async function getStacLanding(transport, request = {}) {
+    const params = createOgcMetadataParams(request);
+    const base = stacBase(request);
+    return transport.requestCachedMetadataJson(`stac:landing:${base}:${params.toString()}`, `${base}?${params.toString()}`, request);
+}
+export async function listStacCollections(transport, request = {}) {
+    const params = createOgcMetadataParams(request);
+    const base = stacBase(request);
+    return transport.requestCachedMetadataJson(`stac:collections:${base}:${params.toString()}`, `${base}/collections?${params.toString()}`, request);
+}
+export async function getStacCollection(transport, request) {
+    const params = createOgcMetadataParams(request);
+    const base = stacBase(request);
+    return transport.requestCachedMetadataJson(`stac:collection:${base}:${request.collectionId}:${params.toString()}`, `${base}/collections/${encodeURIComponent(String(request.collectionId))}?${params.toString()}`, request);
+}
+export async function getStacItem(transport, request) {
+    const params = createOgcMetadataParams(request);
+    const base = stacBase(request);
+    const path = `${base}/collections/${encodeURIComponent(String(request.collectionId))}` +
+        `/items/${encodeURIComponent(String(request.itemId))}`;
+    return transport.requestJson("GET", `${path}?${params.toString()}`, undefined, request.signal);
+}
+export async function searchStac(transport, request = {}) {
+    const base = stacBase(request);
+    if (request.usePost) {
+        return transport.requestJson("POST", `${base}/search`, {
+            headers: mergeHeaders({ "Content-Type": "application/json", Accept: "application/json" }),
+            body: JSON.stringify(stacSearchBody(request)),
+        }, request.signal);
+    }
+    const params = serializeStacSearchParams(request);
+    return transport.requestJson("GET", `${base}/search?${params.toString()}`, undefined, request.signal);
+}
+function serializeStacSearchParams(request) {
+    const params = new URLSearchParams();
+    if (request.bbox !== undefined)
+        params.set("bbox", request.bbox.join(","));
+    if (request.datetime !== undefined)
+        params.set("datetime", request.datetime);
+    if (request.ids !== undefined && request.ids.length > 0)
+        params.set("ids", request.ids.join(","));
+    if (request.collections !== undefined && request.collections.length > 0) {
+        params.set("collections", request.collections.join(","));
+    }
+    // honua-server accepts `intersects` on GET as a JSON-encoded geometry
+    // and `fields` as a CSV with `-` prefix marking excludes (matches
+    // STAC Item Search GET conventions and the server's parser).
+    if (request.intersects !== undefined)
+        params.set("intersects", JSON.stringify(request.intersects));
+    const fields = stacFieldsCsv(request.fields);
+    if (fields !== undefined)
+        params.set("fields", fields);
+    if (request.filter !== undefined)
+        params.set("filter", request.filter);
+    if (request.filterLang !== undefined)
+        params.set("filter-lang", request.filterLang);
+    if (request.limit !== undefined)
+        params.set("limit", String(request.limit));
+    // honua-server uses numeric `offset` paging on GET. `next` is kept as
+    // optional support for STAC servers that advertise an opaque token.
+    if (request.offset !== undefined)
+        params.set("offset", String(request.offset));
+    if (request.next !== undefined)
+        params.set("next", request.next);
+    if (request.sortby !== undefined)
+        params.set("sortby", request.sortby);
+    return params;
+}
+function stacSearchBody(request) {
+    const out = {};
+    if (request.bbox !== undefined)
+        out.bbox = request.bbox;
+    if (request.datetime !== undefined)
+        out.datetime = request.datetime;
+    if (request.intersects !== undefined)
+        out.intersects = request.intersects;
+    if (request.ids !== undefined)
+        out.ids = request.ids;
+    if (request.collections !== undefined)
+        out.collections = request.collections;
+    if (request.filter !== undefined)
+        out.filter = request.filter;
+    if (request.filterLang !== undefined)
+        out["filter-lang"] = request.filterLang;
+    if (request.limit !== undefined)
+        out.limit = request.limit;
+    if (request.offset !== undefined)
+        out.offset = request.offset;
+    if (request.next !== undefined)
+        out.next = request.next;
+    if (request.sortby !== undefined)
+        out.sortby = request.sortby;
+    if (request.fields !== undefined)
+        out.fields = request.fields;
+    return out;
+}
+function stacFieldsCsv(fields) {
+    if (!fields)
+        return undefined;
+    const parts = [];
+    if (fields.include) {
+        for (const f of fields.include) {
+            if (typeof f === "string" && f.length > 0)
+                parts.push(f);
+        }
+    }
+    if (fields.exclude) {
+        for (const f of fields.exclude) {
+            if (typeof f === "string" && f.length > 0)
+                parts.push(`-${f}`);
+        }
+    }
+    return parts.length > 0 ? parts.join(",") : undefined;
+}