@honua/app-platform 0.0.20-alpha.0

package/core/wfs-capabilities.js

@@ -0,0 +1,490 @@
+/**
+ * Hand-rolled XML walker for the two WFS surfaces that the canonical adapter
+ * actually has to read: `wfs:WFS_Capabilities` (operation list, output formats
+ * by operation, advertised feature types, filter capabilities, stored-query
+ * names) and `ows:ExceptionReport` (turned into `HonuaWfsExceptionError`).
+ *
+ * Scope is intentionally narrow — never touches feature payloads, only
+ * metadata XML — so a hand-rolled walker beats pulling in a generic XML
+ * parser as a runtime dependency. The walker:
+ *
+ * - Refuses any document with `<!DOCTYPE …>` or `<!ENTITY …>` declarations.
+ *   Stops XXE-class attacks before any property is read.
+ * - Is namespace-aware in the loose sense: it matches local element names
+ *   (the suffix after `:`) and ignores prefixes, since WFS 2.0 uses several
+ *   different prefix conventions in the wild.
+ * - Returns plain typed structs — no dependency on `xmldom`,
+ *   `fast-xml-parser`, or other third-party libraries.
+ *
+ * @module
+ */
+import { HonuaWfsExceptionError } from "./errors.js";
+/**
+ * Parse a WFS `GetCapabilities` document. Throws when the document declares
+ * a DOCTYPE / ENTITY (XXE defense) or when the root element is not
+ * `WFS_Capabilities` / not parseable.
+ */
+export function parseWfsCapabilities(xml) {
+    const root = parseXml(xml);
+    if (root.local !== "WFS_Capabilities") {
+        if (root.local === "ExceptionReport") {
+            const report = parseExceptionFromRoot(root);
+            throw new HonuaWfsExceptionError(report.exceptionCode, report.message, report.locator);
+        }
+        throw new Error(`WFS GetCapabilities: expected <WFS_Capabilities>, got <${root.qname}>`);
+    }
+    const version = root.attributes.version;
+    const operationsList = findChild(root, "OperationsMetadata")
+        ? findChildren(findChildOrThrow(root, "OperationsMetadata"), "Operation")
+        : [];
+    const operations = new Map();
+    const outputFormatsByOp = new Map();
+    for (const op of operationsList) {
+        const name = op.attributes.name;
+        if (!name)
+            continue;
+        const methods = [];
+        let getUrl;
+        let postUrl;
+        for (const dcp of findChildren(op, "DCP")) {
+            const http = findChild(dcp, "HTTP");
+            if (!http)
+                continue;
+            for (const method of http.children) {
+                // The XML walker strips the `xlink:` prefix, so the href attribute
+                // is keyed as `href`.
+                if (method.local === "Get") {
+                    methods.push("GET");
+                    if (getUrl === undefined && method.attributes.href)
+                        getUrl = method.attributes.href;
+                }
+                if (method.local === "Post") {
+                    methods.push("POST");
+                    if (postUrl === undefined && method.attributes.href)
+                        postUrl = method.attributes.href;
+                }
+            }
+        }
+        const outputFormats = [];
+        for (const param of findChildren(op, "Parameter")) {
+            if (param.attributes.name?.toLowerCase() !== "outputformat")
+                continue;
+            for (const allowed of findChildren(param, "AllowedValues")) {
+                for (const value of findChildren(allowed, "Value")) {
+                    const text = value.text.trim();
+                    if (text)
+                        outputFormats.push(text.toLowerCase());
+                }
+            }
+            // Older WFS servers advertise output formats as direct <Value> children
+            // of <Parameter> instead of nested in <AllowedValues>.
+            for (const value of findChildren(param, "Value")) {
+                const text = value.text.trim();
+                if (text)
+                    outputFormats.push(text.toLowerCase());
+            }
+        }
+        operations.set(name, {
+            name,
+            methods: [...new Set(methods)],
+            outputFormats,
+            ...(getUrl !== undefined ? { getUrl } : {}),
+            ...(postUrl !== undefined ? { postUrl } : {}),
+        });
+        outputFormatsByOp.set(name, outputFormats);
+    }
+    const featureTypeList = findChild(root, "FeatureTypeList");
+    const featureTypes = [];
+    if (featureTypeList) {
+        for (const ft of findChildren(featureTypeList, "FeatureType")) {
+            const nameNode = findChild(ft, "Name");
+            const titleNode = findChild(ft, "Title");
+            const defaultCrsNode = findChild(ft, "DefaultCRS") ?? findChild(ft, "DefaultSRS");
+            const bboxNode = findChild(ft, "WGS84BoundingBox");
+            const lowerCorner = bboxNode ? findChild(bboxNode, "LowerCorner") : undefined;
+            const upperCorner = bboxNode ? findChild(bboxNode, "UpperCorner") : undefined;
+            const entry = {
+                name: nameNode?.text.trim() ?? "",
+            };
+            if (titleNode?.text)
+                entry.title = titleNode.text.trim();
+            if (defaultCrsNode?.text)
+                entry.defaultCrs = defaultCrsNode.text.trim();
+            if (lowerCorner && upperCorner) {
+                const [xmin, ymin] = lowerCorner.text.trim().split(/\s+/).map(Number);
+                const [xmax, ymax] = upperCorner.text.trim().split(/\s+/).map(Number);
+                if (Number.isFinite(xmin) && Number.isFinite(ymin) && Number.isFinite(xmax) && Number.isFinite(ymax)) {
+                    entry.wgs84BoundingBox = { xmin, ymin, xmax, ymax };
+                }
+            }
+            if (entry.name)
+                featureTypes.push(entry);
+        }
+    }
+    const filterCapabilities = parseFilterCapabilities(findChild(root, "Filter_Capabilities"));
+    const storedQueryNames = parseStoredQueryNames(root);
+    const snapshot = {
+        operations,
+        outputFormatsByOp,
+        featureTypes,
+        filterCapabilities,
+        storedQueryNames,
+    };
+    if (version)
+        snapshot.version = version;
+    return snapshot;
+}
+/**
+ * Parse an `ows:ExceptionReport` document into structured fields. Used when
+ * the client sees a non-200 response carrying an XML body or when a
+ * GetCapabilities call returns an ExceptionReport.
+ */
+export function parseWfsExceptionReport(xml) {
+    const root = parseXml(xml);
+    if (root.local !== "ExceptionReport") {
+        throw new Error(`WFS ExceptionReport: expected <ExceptionReport>, got <${root.qname}>`);
+    }
+    return parseExceptionFromRoot(root);
+}
+function parseExceptionFromRoot(root) {
+    const exception = findChild(root, "Exception");
+    if (!exception) {
+        return { exceptionCode: "UnknownException", message: "ExceptionReport without <Exception>" };
+    }
+    const code = exception.attributes.exceptionCode ?? "UnknownException";
+    const locator = exception.attributes.locator;
+    const text = findChild(exception, "ExceptionText");
+    const message = text ? text.text.trim() : "";
+    const out = {
+        exceptionCode: code,
+        message: message || code,
+    };
+    if (locator)
+        out.locator = locator;
+    return out;
+}
+function parseFilterCapabilities(node) {
+    if (!node) {
+        return { spatial: [], scalar: [], temporal: [] };
+    }
+    const spatial = [];
+    const scalar = [];
+    const temporal = [];
+    const spatialOps = findChild(findChild(node, "Spatial_Capabilities"), "SpatialOperators");
+    if (spatialOps) {
+        for (const op of findChildren(spatialOps, "SpatialOperator")) {
+            if (op.attributes.name)
+                spatial.push(op.attributes.name);
+        }
+    }
+    const scalarOps = findChild(findChild(node, "Scalar_Capabilities"), "ComparisonOperators");
+    if (scalarOps) {
+        for (const op of findChildren(scalarOps, "ComparisonOperator")) {
+            const text = op.text.trim();
+            if (text)
+                scalar.push(text);
+        }
+    }
+    const temporalOps = findChild(findChild(node, "Temporal_Capabilities"), "TemporalOperators");
+    if (temporalOps) {
+        for (const op of findChildren(temporalOps, "TemporalOperator")) {
+            if (op.attributes.name)
+                temporal.push(op.attributes.name);
+        }
+    }
+    return { spatial, scalar, temporal };
+}
+function parseStoredQueryNames(root) {
+    // `wfs:WFS_Capabilities` itself does not carry stored queries; they come
+    // back through a separate `ListStoredQueries` operation. Some servers do
+    // include a sibling `<wfs:StoredQueries>` block as an extension; capture
+    // names if present, otherwise return empty.
+    const stored = findChild(root, "StoredQueries");
+    if (!stored)
+        return [];
+    const ids = [];
+    for (const sq of findChildren(stored, "StoredQuery")) {
+        if (sq.attributes.id)
+            ids.push(sq.attributes.id);
+    }
+    return ids;
+}
+/**
+ * Parse the `ListStoredQueriesResponse` body — a flat list of
+ * `<wfs:StoredQuery id="...">` elements. Returned by `HonuaWfs.storedQueries()`.
+ */
+export function parseListStoredQueriesResponse(xml) {
+    const root = parseXml(xml);
+    if (root.local !== "ListStoredQueriesResponse") {
+        if (root.local === "ExceptionReport") {
+            const report = parseExceptionFromRoot(root);
+            throw new HonuaWfsExceptionError(report.exceptionCode, report.message, report.locator);
+        }
+        throw new Error(`WFS ListStoredQueries: expected <ListStoredQueriesResponse>, got <${root.qname}>`);
+    }
+    const ids = [];
+    for (const sq of findChildren(root, "StoredQuery")) {
+        if (sq.attributes.id)
+            ids.push(sq.attributes.id);
+    }
+    return ids;
+}
+export function parseWfsTransactionResponse(xml) {
+    const root = parseXml(xml);
+    if (root.local !== "TransactionResponse") {
+        if (root.local === "ExceptionReport") {
+            const report = parseExceptionFromRoot(root);
+            throw new HonuaWfsExceptionError(report.exceptionCode, report.message, report.locator);
+        }
+        throw new Error(`WFS Transaction: expected <TransactionResponse>, got <${root.qname}>`);
+    }
+    const summary = findChild(root, "TransactionSummary");
+    const totalInserted = summary ? parseIntOrZero(findChild(summary, "totalInserted")?.text) : 0;
+    const totalUpdated = summary ? parseIntOrZero(findChild(summary, "totalUpdated")?.text) : 0;
+    const totalDeleted = summary ? parseIntOrZero(findChild(summary, "totalDeleted")?.text) : 0;
+    const insertResultsNode = findChild(root, "InsertResults");
+    const insertResults = [];
+    if (insertResultsNode) {
+        for (const feature of findChildren(insertResultsNode, "Feature")) {
+            const handle = feature.attributes.handle;
+            const ids = [];
+            for (const ref of findChildren(feature, "ResourceId")) {
+                if (ref.attributes.rid)
+                    ids.push(ref.attributes.rid);
+            }
+            // Older WFS implementations used `<ogc:FeatureId fid="...">`.
+            for (const ref of findChildren(feature, "FeatureId")) {
+                if (ref.attributes.fid)
+                    ids.push(ref.attributes.fid);
+            }
+            const entry = { ids };
+            if (handle)
+                entry.handle = handle;
+            insertResults.push(entry);
+        }
+    }
+    return { totalInserted, totalUpdated, totalDeleted, insertResults };
+}
+function parseIntOrZero(value) {
+    if (!value)
+        return 0;
+    const n = Number(value.trim());
+    return Number.isFinite(n) ? Math.trunc(n) : 0;
+}
+// ── XML walker ───────────────────────────────────────────────
+/**
+ * Parse a small, well-formed XML document into an in-memory tree. The walker
+ * intentionally does not try to be a full XML 1.0 parser — it covers the
+ * subset that WFS / OWS ExceptionReport / ListStoredQueries / Transaction
+ * documents actually emit.
+ *
+ * Hard-fail on `<!DOCTYPE` / `<!ENTITY` / `<!--` declarations involving
+ * external IDs to defend against XXE.
+ */
+export function parseXml(xml) {
+    if (typeof xml !== "string" || xml.length === 0) {
+        throw new Error("WFS XML parser: empty document");
+    }
+    // XXE / external-entity defense: refuse documents that declare a DOCTYPE
+    // (which is the only way to introduce ENTITY declarations in XML 1.0).
+    // This is intentionally strict — Honua's WFS surfaces never emit a
+    // DOCTYPE, and doing so on third-party servers does not unlock anything
+    // we want to read here.
+    const lower = xml.toLowerCase();
+    if (lower.includes("<!doctype") || lower.includes("<!entity")) {
+        throw new Error("WFS XML parser: DOCTYPE / ENTITY declarations are rejected");
+    }
+    const stripped = stripPrologAndComments(xml);
+    const len = stripped.length;
+    let i = 0;
+    const stack = [];
+    let root;
+    while (i < len) {
+        if (stripped[i] === "<") {
+            if (stripped.startsWith("<?", i)) {
+                const end = stripped.indexOf("?>", i + 2);
+                if (end === -1)
+                    throw new Error("WFS XML parser: unterminated processing instruction");
+                i = end + 2;
+                continue;
+            }
+            if (stripped.startsWith("<!--", i)) {
+                const end = stripped.indexOf("-->", i + 4);
+                if (end === -1)
+                    throw new Error("WFS XML parser: unterminated comment");
+                i = end + 3;
+                continue;
+            }
+            if (stripped.startsWith("<![CDATA[", i)) {
+                const end = stripped.indexOf("]]>", i + 9);
+                if (end === -1)
+                    throw new Error("WFS XML parser: unterminated CDATA");
+                const text = stripped.slice(i + 9, end);
+                const top = stack[stack.length - 1];
+                if (top)
+                    top.text += text;
+                i = end + 3;
+                continue;
+            }
+            // Closing tag.
+            if (stripped[i + 1] === "/") {
+                const end = stripped.indexOf(">", i + 2);
+                if (end === -1)
+                    throw new Error("WFS XML parser: unterminated closing tag");
+                const closing = stripped.slice(i + 2, end).trim();
+                const top = stack[stack.length - 1];
+                if (!top)
+                    throw new Error(`WFS XML parser: stray closing tag </${closing}>`);
+                if (top.qname !== closing) {
+                    throw new Error(`WFS XML parser: mismatched closing tag </${closing}> (expected </${top.qname}>)`);
+                }
+                stack.pop();
+                i = end + 1;
+                continue;
+            }
+            // Opening (or self-closing) tag.
+            const end = findTagEnd(stripped, i);
+            if (end === -1)
+                throw new Error("WFS XML parser: unterminated opening tag");
+            const inner = stripped.slice(i + 1, end);
+            const selfClosing = inner.endsWith("/");
+            const tagBody = selfClosing ? inner.slice(0, -1).trim() : inner.trim();
+            const { name, attributes } = parseTagBody(tagBody);
+            const local = stripPrefix(name);
+            const node = {
+                local,
+                qname: name,
+                attributes,
+                children: [],
+                text: "",
+            };
+            const top = stack[stack.length - 1];
+            if (top)
+                top.children.push(node);
+            else if (root) {
+                throw new Error("WFS XML parser: multiple root elements");
+            }
+            else {
+                root = node;
+            }
+            if (!selfClosing)
+                stack.push(node);
+            i = end + 1;
+            continue;
+        }
+        // Text node — accumulate against the current top, decoding entities.
+        const next = stripped.indexOf("<", i);
+        const text = stripped.slice(i, next === -1 ? len : next);
+        const top = stack[stack.length - 1];
+        if (top)
+            top.text += decodeXmlEntities(text);
+        i = next === -1 ? len : next;
+    }
+    if (stack.length > 0) {
+        throw new Error(`WFS XML parser: unclosed element <${stack[stack.length - 1].qname}>`);
+    }
+    if (!root) {
+        throw new Error("WFS XML parser: no root element");
+    }
+    return root;
+}
+function stripPrologAndComments(xml) {
+    // Trim BOM and leading whitespace.
+    let out = xml;
+    if (out.charCodeAt(0) === 0xfeff)
+        out = out.slice(1);
+    return out.trim();
+}
+function findTagEnd(xml, start) {
+    // The tag body may contain attributes whose values are double- or single-quoted
+    // and could legitimately contain `>` characters. Track quote state.
+    let i = start + 1;
+    let quote;
+    while (i < xml.length) {
+        const ch = xml[i];
+        if (quote) {
+            if (ch === quote)
+                quote = undefined;
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+        }
+        else if (ch === ">") {
+            return i;
+        }
+        i += 1;
+    }
+    return -1;
+}
+function parseTagBody(body) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        throw new Error("WFS XML parser: empty tag");
+    // Tag name runs to the first whitespace; attributes follow.
+    let i = 0;
+    while (i < trimmed.length && !/\s/.test(trimmed[i]))
+        i += 1;
+    const name = trimmed.slice(0, i);
+    if (!name)
+        throw new Error("WFS XML parser: missing tag name");
+    const attributes = {};
+    let j = i;
+    while (j < trimmed.length) {
+        while (j < trimmed.length && /\s/.test(trimmed[j]))
+            j += 1;
+        if (j >= trimmed.length)
+            break;
+        const eq = trimmed.indexOf("=", j);
+        if (eq === -1)
+            break;
+        const attrName = trimmed.slice(j, eq).trim();
+        let k = eq + 1;
+        while (k < trimmed.length && /\s/.test(trimmed[k]))
+            k += 1;
+        const quote = trimmed[k];
+        if (quote !== '"' && quote !== "'") {
+            throw new Error(`WFS XML parser: attribute "${attrName}" must be quoted`);
+        }
+        const close = trimmed.indexOf(quote, k + 1);
+        if (close === -1)
+            throw new Error(`WFS XML parser: unterminated attribute value for "${attrName}"`);
+        const rawValue = trimmed.slice(k + 1, close);
+        attributes[stripPrefix(attrName)] = decodeXmlEntities(rawValue);
+        j = close + 1;
+    }
+    return { name, attributes };
+}
+function stripPrefix(name) {
+    const idx = name.indexOf(":");
+    return idx === -1 ? name : name.slice(idx + 1);
+}
+function decodeXmlEntities(text) {
+    if (!text.includes("&"))
+        return text;
+    return text
+        .replaceAll("&lt;", "<")
+        .replaceAll("&gt;", ">")
+        .replaceAll("&quot;", '"')
+        .replaceAll("&apos;", "'")
+        .replaceAll("&amp;", "&");
+}
+function findChild(node, local) {
+    if (!node)
+        return undefined;
+    for (const child of node.children) {
+        if (child.local === local)
+            return child;
+    }
+    return undefined;
+}
+function findChildOrThrow(node, local) {
+    const found = findChild(node, local);
+    if (!found)
+        throw new Error(`WFS XML parser: missing child <${local}> on <${node.qname}>`);
+    return found;
+}
+function findChildren(node, local) {
+    if (!node)
+        return [];
+    return node.children.filter((c) => c.local === local);
+}

package/core/wfs-filter.d.ts

@@ -0,0 +1,118 @@
+/**
+ * FES 2.0 Filter Encoding emitter for the WFS adapter. Two responsibilities:
+ *
+ * - Compile the canonical `Query.where` SQL-92-ish expression into a small
+ *   FES AST. The supported subset is documented in `docs/wfs.md` —
+ *   comparison operators, `IN`, `BETWEEN`, `LIKE`, `IS NULL`, boolean
+ *   combinators, parenthesization, and string / number literals. Anything
+ *   richer (subqueries, function calls, vendor extensions) yields the
+ *   sentinel `"unsupported"` so the caller throws
+ *   `HonuaCapabilityNotSupportedError("query")` rather than ship a
+ *   silent partial filter.
+ *
+ * - Translate `Query.spatialFilter` into a spatial FES predicate. Only the
+ *   simple geometries the canonical surface emits are supported — envelope,
+ *   point, polygon, polyline. Curves and surfaces are out of scope; callers
+ *   that need them reach the wire through `Source.protocol("wfs")`.
+ *
+ * The emitter never reaches `fetch`; it returns plain strings the adapter
+ * splices into the URL (KVP `filter=`) or the POST body (`<fes:Filter>`).
+ *
+ * @module
+ */
+import type { SpatialFilter } from "./spatial-filter.js";
+/**
+ * Sentinel used by the `where` compiler when the input contains a construct
+ * the FES emitter does not know how to translate. Callers should treat this
+ * as "fail the query" rather than "emit a partial filter".
+ */
+export declare const UNSUPPORTED_FES: "unsupported";
+export type FesCompileResult = FesNode | typeof UNSUPPORTED_FES;
+export type FesNode = {
+    kind: "and";
+    operands: readonly FesNode[];
+} | {
+    kind: "or";
+    operands: readonly FesNode[];
+} | {
+    kind: "not";
+    operand: FesNode;
+} | {
+    kind: "compare";
+    op: FesCompareOp;
+    property: string;
+    value: FesLiteral;
+} | {
+    kind: "between";
+    property: string;
+    lower: FesLiteral;
+    upper: FesLiteral;
+} | {
+    kind: "in";
+    property: string;
+    values: readonly FesLiteral[];
+} | {
+    kind: "like";
+    property: string;
+    pattern: string;
+} | {
+    kind: "isNull";
+    property: string;
+} | {
+    kind: "spatial";
+    op: FesSpatialOp;
+    property: string;
+    gml: string;
+} | {
+    kind: "bbox";
+    property: string;
+    envelope: {
+        xmin: number;
+        ymin: number;
+        xmax: number;
+        ymax: number;
+        srsName?: string;
+    };
+};
+export type FesCompareOp = "=" | "<>" | "<" | "<=" | ">" | ">=";
+export type FesSpatialOp = "Intersects" | "Within" | "Contains" | "Crosses" | "Disjoint" | "Touches" | "Overlaps" | "Equals";
+export type FesLiteral = {
+    kind: "string";
+    value: string;
+} | {
+    kind: "number";
+    value: number;
+};
+/**
+ * Compile a `Query.where` SQL-92 string into FES AST. Returns
+ * `UNSUPPORTED_FES` for inputs the emitter cannot translate; the adapter
+ * promotes this to `HonuaCapabilityNotSupportedError("query")`.
+ */
+export declare function compileWhere(input: string | undefined): FesCompileResult;
+/**
+ * Compile the canonical `SpatialFilter` (Esri-flavored) into the FES spatial
+ * leaf the adapter splices into the request. Default geometry property
+ * name is `the_geom`; callers may override (some servers use `geometry`,
+ * `shape`, etc.).
+ */
+export declare function compileSpatialFilter(filter: SpatialFilter, options: {
+    geometryProperty: string;
+    srsName?: string;
+}): FesCompileResult;
+/**
+ * Serialize a list of FES nodes into a single `<fes:Filter>` element. Used
+ * for both the POST GetFeature body and (URL-encoded) the KVP `filter=`
+ * query parameter.
+ *
+ * The FES namespace prefix is always `fes` and is bound on the root
+ * `<fes:Filter>` element so the result is self-contained.
+ */
+export declare function serializeFes(nodes: readonly FesNode[], options?: {
+    typeName?: string;
+}): string;
+/**
+ * Convert a canonical `CanonicalFeature.geometry` (GeoJSON) into a GML 3.2
+ * fragment for `<wfs:Insert>` / `<wfs:Update>` payloads.
+ */
+export declare function geoJsonGeometryToGml(geometry: unknown, srsName: string | undefined): string | undefined;
+//# sourceMappingURL=wfs-filter.d.ts.map

package/core/wfs-filter.d.ts.map

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