@honua/app-platform 0.0.20-alpha.0

package/core/esri-geojson.js

@@ -0,0 +1,363 @@
+/**
+ * Convert Esri-JSON geometry (as returned by `queryFeatures` and contract
+ * {@link HonuaFeature} results) into standard GeoJSON geometry.
+ *
+ * Esri encodes geometry as `{ x, y }` points, `{ paths }` polylines,
+ * `{ rings }` polygons, `{ points }` multipoints, and `{ xmin, ymin, xmax,
+ * ymax }` envelopes. GeoJSON consumers (MapLibre, Leaflet, turf, etc.) expect
+ * `Point` / `LineString` / `Polygon` and their `Multi*` variants. This module
+ * provides that translation as a first-class, dependency-free utility.
+ *
+ * Polygon rings are grouped following the Esri convention where clockwise
+ * rings are exterior and counter-clockwise rings are holes, producing `Polygon`
+ * for a single exterior ring and `MultiPolygon` when several exterior rings are
+ * present. The emitted rings are rewound to the GeoJSON RFC 7946 right-hand rule
+ * (counter-clockwise exterior, clockwise holes) so conformant consumers do not
+ * interpret polygons inside-out.
+ *
+ * @module
+ */
+function isFinitePosition(value) {
+    return (Array.isArray(value) &&
+        value.length >= 2 &&
+        typeof value[0] === "number" &&
+        Number.isFinite(value[0]) &&
+        typeof value[1] === "number" &&
+        Number.isFinite(value[1]));
+}
+function collectFinitePositions(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isFinitePosition);
+}
+function collectPositionSets(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => collectFinitePositions(entry)).filter((entry) => entry.length > 0);
+}
+function computeRingSignedArea(ring) {
+    if (ring.length < 3) {
+        return 0;
+    }
+    let area = 0;
+    for (let index = 0; index < ring.length; index += 1) {
+        const current = ring[index];
+        const next = ring[(index + 1) % ring.length];
+        if (!current || !next) {
+            continue;
+        }
+        area += current[0] * next[1] - next[0] * current[1];
+    }
+    return area / 2;
+}
+/**
+ * Esri uses clockwise (negative signed area in screen/standard math
+ * orientation) rings for exterior boundaries and counter-clockwise rings for
+ * holes.
+ */
+function isExteriorRing(ring) {
+    return computeRingSignedArea(ring) < 0;
+}
+function isPointOnSegment(point, segmentStart, segmentEnd) {
+    const epsilon = 1e-9;
+    const crossProduct = (point[0] - segmentStart[0]) * (segmentEnd[1] - segmentStart[1]) -
+        (point[1] - segmentStart[1]) * (segmentEnd[0] - segmentStart[0]);
+    if (Math.abs(crossProduct) > epsilon) {
+        return false;
+    }
+    const dotProduct = (point[0] - segmentStart[0]) * (segmentEnd[0] - segmentStart[0]) +
+        (point[1] - segmentStart[1]) * (segmentEnd[1] - segmentStart[1]);
+    if (dotProduct < -epsilon) {
+        return false;
+    }
+    const segmentLengthSquared = (segmentEnd[0] - segmentStart[0]) * (segmentEnd[0] - segmentStart[0]) +
+        (segmentEnd[1] - segmentStart[1]) * (segmentEnd[1] - segmentStart[1]);
+    return dotProduct - segmentLengthSquared <= epsilon;
+}
+function isPointInsideRing(point, ring) {
+    if (ring.length < 3) {
+        return false;
+    }
+    let isInside = false;
+    for (let index = 0, previousIndex = ring.length - 1; index < ring.length; previousIndex = index, index += 1) {
+        const current = ring[index];
+        const previous = ring[previousIndex];
+        if (!current || !previous) {
+            continue;
+        }
+        if (isPointOnSegment(point, previous, current)) {
+            return true;
+        }
+        const intersects = current[1] > point[1] !== previous[1] > point[1] &&
+            point[0] < ((previous[0] - current[0]) * (point[1] - current[1])) / (previous[1] - current[1]) + current[0];
+        if (intersects) {
+            isInside = !isInside;
+        }
+    }
+    return isInside;
+}
+function findContainingPolygonIndex(polygons, outerAreas, ring) {
+    const samplePoint = ring[0];
+    if (!samplePoint) {
+        return -1;
+    }
+    let containingPolygonIndex = -1;
+    let smallestContainingArea = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < polygons.length; index += 1) {
+        const polygon = polygons[index];
+        const outerRing = polygon?.[0];
+        const outerArea = outerAreas[index];
+        if (!outerRing || outerArea === undefined || !isPointInsideRing(samplePoint, outerRing)) {
+            continue;
+        }
+        if (outerArea < smallestContainingArea) {
+            smallestContainingArea = outerArea;
+            containingPolygonIndex = index;
+        }
+    }
+    return containingPolygonIndex;
+}
+/**
+ * Rewind a ring to the GeoJSON RFC 7946 §3.1.6 right-hand rule: exterior rings
+ * counter-clockwise (positive signed area), interior rings (holes) clockwise
+ * (negative signed area). Esri uses the opposite convention (clockwise
+ * exterior), so emitting Esri rings verbatim produces GeoJSON that
+ * RFC 7946-conformant consumers (and the S2 spherical winding used by some
+ * renderers) interpret inside-out.
+ */
+function rewindRingForGeoJson(ring, exterior) {
+    const copy = ring.map((position) => [...position]);
+    const area = computeRingSignedArea(copy);
+    if (area === 0) {
+        return copy;
+    }
+    const correctlyWound = exterior ? area > 0 : area < 0;
+    return correctlyWound ? copy : copy.reverse();
+}
+function rewindPolygonForGeoJson(polygon) {
+    return polygon.map((ring, index) => rewindRingForGeoJson(ring, index === 0));
+}
+function convertPolygonRings(rings) {
+    const polygons = [];
+    const outerAreas = [];
+    const interiorRings = [];
+    for (const ring of rings) {
+        if (isExteriorRing(ring)) {
+            polygons.push([ring]);
+            outerAreas.push(Math.abs(computeRingSignedArea(ring)));
+            continue;
+        }
+        interiorRings.push(ring);
+    }
+    for (const ring of interiorRings) {
+        const containingPolygonIndex = findContainingPolygonIndex(polygons, outerAreas, ring);
+        if (containingPolygonIndex < 0) {
+            polygons.push([ring]);
+            outerAreas.push(Math.abs(computeRingSignedArea(ring)));
+            continue;
+        }
+        polygons[containingPolygonIndex]?.push(ring);
+    }
+    return polygons.length === 1
+        ? {
+            type: "Polygon",
+            coordinates: rewindPolygonForGeoJson(polygons[0] ?? []),
+        }
+        : {
+            type: "MultiPolygon",
+            coordinates: polygons.map(rewindPolygonForGeoJson),
+        };
+}
+function hasNumber(geometry, key) {
+    return typeof geometry[key] === "number" && Number.isFinite(geometry[key]);
+}
+/**
+ * Convert a single Esri-JSON geometry into a GeoJSON geometry.
+ *
+ * Supports Esri point (`{ x, y }`), multipoint (`{ points }`), polyline
+ * (`{ paths }`), polygon (`{ rings }`), and envelope (`{ xmin, ymin, xmax,
+ * ymax }`) shapes. Returns `null` for `null`/`undefined` input and for
+ * geometries that contain no finite coordinates (e.g. empty `rings`/`paths`).
+ *
+ * @param geometry Esri geometry, the `geometry` field of a {@link HonuaFeature},
+ *   or `null`/`undefined`.
+ * @returns The equivalent GeoJSON geometry, or `null` when the input is empty
+ *   or unrecognized.
+ */
+export function esriGeometryToGeoJSON(geometry) {
+    if (!geometry || typeof geometry !== "object") {
+        return null;
+    }
+    const candidate = geometry;
+    if (hasNumber(candidate, "x") && hasNumber(candidate, "y")) {
+        return {
+            type: "Point",
+            coordinates: [candidate.x, candidate.y],
+        };
+    }
+    if (Array.isArray(candidate.points)) {
+        const coordinates = collectFinitePositions(candidate.points);
+        if (coordinates.length < 1) {
+            return null;
+        }
+        return {
+            type: "MultiPoint",
+            coordinates,
+        };
+    }
+    if (Array.isArray(candidate.paths)) {
+        const coordinates = collectPositionSets(candidate.paths);
+        if (coordinates.length < 1) {
+            return null;
+        }
+        return coordinates.length === 1
+            ? {
+                type: "LineString",
+                coordinates: coordinates[0] ?? [],
+            }
+            : {
+                type: "MultiLineString",
+                coordinates,
+            };
+    }
+    if (Array.isArray(candidate.rings)) {
+        const coordinates = collectPositionSets(candidate.rings);
+        if (coordinates.length < 1) {
+            return null;
+        }
+        return convertPolygonRings(coordinates);
+    }
+    if (hasNumber(candidate, "xmin") &&
+        hasNumber(candidate, "ymin") &&
+        hasNumber(candidate, "xmax") &&
+        hasNumber(candidate, "ymax")) {
+        const xmin = candidate.xmin;
+        const ymin = candidate.ymin;
+        const xmax = candidate.xmax;
+        const ymax = candidate.ymax;
+        return {
+            type: "Polygon",
+            coordinates: [
+                [
+                    [xmin, ymin],
+                    [xmax, ymin],
+                    [xmax, ymax],
+                    [xmin, ymax],
+                    [xmin, ymin],
+                ],
+            ],
+        };
+    }
+    return null;
+}
+function readFeatureId(feature) {
+    const attributes = feature.attributes ?? {};
+    const candidates = [attributes.OBJECTID, attributes.objectid, attributes.id, attributes.ID, attributes.FID];
+    for (const value of candidates) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Convert a contract {@link HonuaFeature} (Esri attributes + geometry) into a
+ * GeoJSON `Feature`.
+ *
+ * The feature `id` is derived from common Esri identifier attributes
+ * (`OBJECTID`, `objectid`, `id`, `ID`, `FID`) when present, and the geometry is
+ * converted with {@link esriGeometryToGeoJSON} (yielding `null` for missing or
+ * empty geometry).
+ *
+ * @param feature A contract feature with Esri-shaped `attributes` and
+ *   `geometry`.
+ * @returns The equivalent GeoJSON feature.
+ */
+export function esriFeatureToGeoJSON(feature) {
+    const id = readFeatureId(feature);
+    return {
+        type: "Feature",
+        ...(id === undefined ? {} : { id }),
+        geometry: esriGeometryToGeoJSON(feature.geometry),
+        properties: feature.attributes ?? {},
+    };
+}
+// ── GeoJSON → Esri (reverse of esriGeometryToGeoJSON) ─────────────
+//
+// The forward converter rewinds rings to the GeoJSON RFC 7946 right-hand rule
+// (counter-clockwise exterior). Esri uses the opposite convention (clockwise
+// exterior, counter-clockwise holes), so this reverse converter rewinds each
+// ring back to the Esri orientation before emitting `{ rings }`.
+function rewindRingForEsri(ring, exterior) {
+    const copy = ring.map((position) => [...position]);
+    const area = computeRingSignedArea(copy);
+    if (area === 0) {
+        return copy;
+    }
+    // Esri: exterior rings are clockwise (negative signed area), holes are
+    // counter-clockwise (positive signed area).
+    const correctlyWound = exterior ? area < 0 : area > 0;
+    return correctlyWound ? copy : copy.reverse();
+}
+function esriRingsFromPolygon(coordinates) {
+    return coordinates.map((ring, index) => rewindRingForEsri(ring, index === 0));
+}
+/**
+ * Convert a standard GeoJSON geometry back into Esri-JSON geometry, the inverse
+ * of {@link esriGeometryToGeoJSON}. `GeometryCollection` is not representable as
+ * a single Esri geometry and yields `null`.
+ *
+ * Polygon/MultiPolygon rings are rewound to the Esri winding convention
+ * (clockwise exterior, counter-clockwise holes) and MultiPolygons are flattened
+ * into a single `{ rings }` list, matching how Esri encodes multi-part polygons.
+ *
+ * @param geometry A GeoJSON geometry, or `null`/`undefined`.
+ * @param spatialReference Optional spatial reference stamped onto the emitted
+ *   Esri geometry (Esri geometries are CRS-tagged; GeoJSON is implicitly WGS84).
+ * @returns The equivalent Esri geometry, or `null` when the input is empty or
+ *   unrepresentable.
+ */
+export function geoJsonToEsriGeometry(geometry, spatialReference) {
+    if (!geometry || typeof geometry !== "object") {
+        return null;
+    }
+    const sr = spatialReference ? { spatialReference } : {};
+    switch (geometry.type) {
+        case "Point": {
+            const [x, y] = geometry.coordinates;
+            if (typeof x !== "number" || typeof y !== "number") {
+                return null;
+            }
+            return { x, y, ...sr };
+        }
+        case "MultiPoint": {
+            return { points: geometry.coordinates.map((position) => [...position]), ...sr };
+        }
+        case "LineString": {
+            return { paths: [geometry.coordinates.map((position) => [...position])], ...sr };
+        }
+        case "MultiLineString": {
+            return {
+                paths: geometry.coordinates.map((line) => line.map((position) => [...position])),
+                ...sr,
+            };
+        }
+        case "Polygon": {
+            return { rings: esriRingsFromPolygon(geometry.coordinates), ...sr };
+        }
+        case "MultiPolygon": {
+            const rings = [];
+            for (const polygon of geometry.coordinates) {
+                rings.push(...esriRingsFromPolygon(polygon));
+            }
+            return { rings, ...sr };
+        }
+        default:
+            return null;
+    }
+}

package/core/geoparquet-sql.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Pure SQL compiler for the GeoParquet / DuckDB-WASM `Source`
+ * (`@honua/sdk-js/geoparquet`). Translates the protocol-neutral
+ * {@link Query} envelope into DuckDB SQL over `read_parquet(...)` with spatial
+ * predicate pushdown.
+ *
+ * This module has **no runtime dependencies** (not even `@duckdb/duckdb-wasm`)
+ * so it can be unit- and snapshot-tested in isolation and so the SQL text is a
+ * pure function of its inputs. The heavy DuckDB orchestration lives in
+ * `src/geoparquet/`.
+ *
+ * ## SQL-injection safety
+ *
+ * Every value this compiler interpolates is either (a) a numeric literal that
+ * is validated to be a finite JS number and rendered with {@link numberLiteral},
+ * (b) a string literal escaped by {@link stringLiteral} (single quotes doubled,
+ * embedded NULs rejected), or (c) a SQL identifier escaped by
+ * {@link quoteIdentifier} (double quotes doubled, embedded NULs / control chars
+ * rejected). The one exception is {@link Query.where}: like the GeoServices and
+ * OGC adapters, `where` is caller-authored filter SQL and is passed through
+ * verbatim (wrapped in parentheses). Callers are responsible for the trust
+ * boundary on `where`, exactly as they are for a GeoServices `where` clause.
+ *
+ * @module
+ */
+import type { AggregationSpec, Query } from "../contract/types.js";
+import type { SpatialFilter } from "./spatial-filter.js";
+/**
+ * Quote a SQL identifier for DuckDB: wrap in double quotes and double any
+ * embedded double quote. Rejects NUL and other control characters, which
+ * cannot appear in a legitimate column name and are a classic smuggling
+ * vector. Overture column names (`id`, `names`, `geometry`, dotted struct
+ * paths accessed as whole columns) are all safe under this rule.
+ */
+export declare function quoteIdentifier(name: string): string;
+/**
+ * Render a string SQL literal (single quotes doubled). Rejects embedded NUL.
+ */
+export declare function stringLiteral(value: string): string;
+/**
+ * Render a numeric SQL literal, validating the input is a finite JS number.
+ * Non-finite values (NaN/Infinity) throw rather than emit `'NaN'` — a spatial
+ * predicate must never silently widen to an infinite envelope.
+ */
+export declare function numberLiteral(value: number): string;
+/**
+ * Render an integer SQL literal (offset / limit). Coerces via `Math.trunc` and
+ * validates non-negative finiteness.
+ */
+export declare function integerLiteral(value: number): string;
+/**
+ * Build the `read_parquet(...)` table expression from one or more file URLs /
+ * globs. A single source renders `read_parquet('url')`; multiple sources
+ * render `read_parquet(['a', 'b'])`. Every URL is escaped as a string literal.
+ * `union_by_name := true` and `hive_partitioning := true` are set so mixed
+ * schemas across a hive-partitioned Overture theme line up by column name.
+ */
+export declare function parquetSourceExpr(urls: readonly string[]): string;
+/**
+ * How the geometry column is physically stored, which decides the SQL used to
+ * (a) evaluate a spatial predicate and (b) project GeoJSON output.
+ *
+ * - `wkb`: GeoParquet 1.0/1.1 well-known-binary BLOB — wrap with
+ *   `ST_GeomFromWKB(...)`.
+ * - `native`: Parquet-native `GEOMETRY` / `GEOGRAPHY` logical type (Parquet
+ *   2.11, Mar 2025) — DuckDB reads it as a `GEOMETRY`, used directly.
+ * - `geojson`: GeoParquet `GeoJSON` encoding (string) — wrap with
+ *   `ST_GeomFromGeoJSON(...)`.
+ */
+export type GeometryEncoding = "wkb" | "native" | "geojson";
+export interface GeometryColumnPlan {
+    /** Geometry column name in the parquet file. */
+    readonly column: string;
+    /** Physical encoding of that column. */
+    readonly encoding: GeometryEncoding;
+    /**
+     * Optional GeoParquet 1.1 "bbox covering" struct column (typically `bbox`
+     * with `xmin`/`ymin`/`xmax`/`ymax` fields). When present, an envelope filter
+     * can prune row groups without decoding any geometry.
+     */
+    readonly bboxColumn?: string;
+}
+/**
+ * SQL expression that yields a DuckDB `GEOMETRY` from the stored geometry
+ * column, adapting to the physical encoding.
+ */
+export declare function geometryExpr(plan: GeometryColumnPlan): string;
+export interface BBox {
+    readonly xmin: number;
+    readonly ymin: number;
+    readonly xmax: number;
+    readonly ymax: number;
+}
+/**
+ * Reduce any Esri-shaped {@link SpatialFilter} geometry to its axis-aligned
+ * bounding box. Envelopes are exact; points, polylines (`paths`), polygons
+ * (`rings`), and multipoints (`points`) are reduced to their coordinate
+ * bounds. Returns `undefined` when the geometry carries no usable coordinates.
+ */
+export declare function bboxFromSpatialFilter(filter: SpatialFilter): BBox | undefined;
+/**
+ * True when the spatial filter is a plain envelope (exact bbox intersection).
+ * Anything else is reduced to its bbox and is therefore an approximation the
+ * caller should be told about via a `degraded` reason.
+ */
+export declare function isEnvelopeFilter(filter: SpatialFilter): boolean;
+/**
+ * Compile the spatial predicate for a bbox against a geometry plan. Prefers the
+ * GeoParquet 1.1 bbox-covering column (row-group-skippable) when present, then
+ * falls back to `ST_Intersects(<geom>, ST_MakeEnvelope(...))`.
+ */
+export declare function spatialPredicate(bbox: BBox, plan: GeometryColumnPlan): string;
+export interface CompileOptions {
+    /** Parquet file URL(s) / glob(s). */
+    readonly sources: readonly string[];
+    /** Geometry column plan (from metadata detection), if the file is spatial. */
+    readonly geometry?: GeometryColumnPlan;
+    /**
+     * All non-geometry column names available in the file, used to expand a
+     * `returnGeometry`-only projection and to validate that requested
+     * `outFields` are addressable. When omitted, `*` (minus geometry) is used.
+     */
+    readonly columns?: readonly string[];
+    /** Output alias for the projected GeoJSON geometry. Defaults to `geometry`. */
+    readonly geometryAlias?: string;
+}
+export interface CompiledSql {
+    readonly sql: string;
+    /** True when a non-envelope spatial filter was reduced to its bbox. */
+    readonly bboxApproximated: boolean;
+}
+/**
+ * Compile a feature {@link Query} into a DuckDB `SELECT`. The geometry column,
+ * when present and `returnGeometry !== false`, is projected as GeoJSON text via
+ * `ST_AsGeoJSON` under the alias `geometry` (overridable).
+ */
+export declare function compileQuery(query: Query, options: CompileOptions): CompiledSql;
+/**
+ * Compile an {@link AggregationSpec} into a GROUP BY `SELECT`. Group-by fields
+ * are echoed in the projection (so the returned rows carry the group key),
+ * followed by each metric expression aliased to its `alias` (or `fn_field`).
+ */
+export declare function compileAggregate(query: Query & {
+    aggregation: AggregationSpec;
+}, options: CompileOptions): CompiledSql;
+/**
+ * SQL that reads the parquet footer schema without scanning rows.
+ */
+export declare function describeSql(sources: readonly string[]): string;
+/**
+ * Cheap row-count estimate from the parquet footer (`num_rows` per row group),
+ * summed across all files. Avoids a full `count(*)` table scan on large
+ * Overture extracts.
+ */
+export declare function rowEstimateSql(sources: readonly string[]): string;
+/**
+ * SQL that reads the GeoParquet `geo` key-value metadata (the JSON blob that
+ * carries `primary_column`, per-column `encoding`, and `crs`). Returns zero
+ * rows for Parquet-native geometry files, which carry no `geo` metadata.
+ */
+export declare function geoMetadataSql(sources: readonly string[]): string;
+//# sourceMappingURL=geoparquet-sql.d.ts.map

package/core/geoparquet-sql.d.ts.map

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