@honua/react 0.0.20-alpha.0 → 0.1.1-beta.0

package/core/errors.js

@@ -1,8 +1,9 @@
 /**
- * Honua SDK error hierarchy. Every error thrown by `@honua/sdk-js` is an
- * instance of one of the classes in this file plus the runtime-type guard
- * `isHonuaError(error)`. See [`docs/errors.md`](../../docs/errors.md) for the
- * full reference table including recovery hints and the retry-policy mapping.
+ * Tagged hierarchy for the migrated Honua SDK error domains. The common
+ * `isHonuaError(error)` guard also recognizes migrated query, map, runtime,
+ * realtime, offline, and plugin subclasses. See
+ * [`docs/errors.md`](../../docs/errors.md) for exact coverage, residual domains,
+ * recovery hints, and the retryability classification.
  *
  * @example
  * ```ts
@@ -29,9 +30,39 @@
  *
  * @packageDocumentation
  */
-import { HonuaJobFailedError } from "./ogc-processes.js";
-import { HonuaWmsCapabilitiesParseError } from "./wms-capabilities.js";
-import { HonuaWmtsCapabilitiesParseError } from "./wmts-capabilities.js";
+import { HonuaSdkError, isHonuaSdkError, mergeHonuaErrorContext, } from "./error-envelope.js";
+/** Discovery input, metadata, or cache identity is invalid or inconsistent. */
+export class HonuaDiscoveryError extends HonuaSdkError {
+    code;
+    detail;
+    constructor(code, message, detail, options = {}) {
+        super(`discovery.${code}`, message, {
+            ...options,
+            context: mergeHonuaErrorContext(detail, options.context),
+        });
+        this.code = code;
+        this.detail = detail;
+        this.name = "HonuaDiscoveryError";
+    }
+}
+/**
+ * Thrown when a geometry cannot be classified without guessing. The structured
+ * `code` and `detail` fields let callers distinguish an unsupported shape from
+ * a recognized-but-malformed Esri geometry without parsing the message.
+ */
+export class HonuaGeometryError extends HonuaSdkError {
+    code;
+    detail;
+    constructor(code, message, detail, options = {}) {
+        super(`core.geometry.${code}`, message, {
+            ...options,
+            context: mergeHonuaErrorContext(detail, options.context),
+        });
+        this.code = code;
+        this.detail = detail;
+        this.name = "HonuaGeometryError";
+    }
+}
 /**
  * Thrown when the server returns a non-2xx HTTP status. Branch on
  * `.statusCode` to decide recovery: refresh credentials on 401/403, respect
@@ -39,49 +70,58 @@ import { HonuaWmtsCapabilitiesParseError } from "./wmts-capabilities.js";
  *
  * @see [`docs/errors.md`](../../docs/errors.md)
  */
-export class HonuaHttpError extends Error {
+export class HonuaHttpError extends HonuaSdkError {
     statusCode;
     body;
-    constructor(statusCode, message, body) {
-        super(`HTTP ${statusCode}: ${message}`);
+    constructor(statusCode, message, body, options = {}) {
+        super(HTTP_RETRYABLE_STATUSES.has(statusCode) ? "core.http.transient" : "core.http.rejected", `HTTP ${statusCode}: ${message}`, {
+            ...options,
+            context: mergeHonuaErrorContext(options.context, { statusCode }),
+        });
         this.name = "HonuaHttpError";
         this.statusCode = statusCode;
         this.body = body;
     }
 }
 /** Thrown when a request exceeds the configured timeout. */
-export class HonuaTimeoutError extends Error {
+export class HonuaTimeoutError extends HonuaSdkError {
     timeoutMs;
-    constructor(timeoutMs) {
-        super(`Request timed out after ${timeoutMs}ms`);
+    constructor(timeoutMs, options = {}) {
+        super("core.timeout", `Request timed out after ${timeoutMs}ms`, {
+            ...options,
+            context: mergeHonuaErrorContext(options.context, { timeoutMs }),
+        });
         this.name = "HonuaTimeoutError";
         this.timeoutMs = timeoutMs;
     }
 }
 /** Thrown when a network-level failure occurs (DNS, connection refused, etc.). */
-export class HonuaNetworkError extends Error {
+export class HonuaNetworkError extends HonuaSdkError {
     cause;
-    constructor(message, cause) {
-        super(message);
+    constructor(message, cause, metadata = {}) {
+        super("core.network", message, { ...metadata, cause });
         this.name = "HonuaNetworkError";
         this.cause = cause;
     }
 }
 /** Thrown when a request is aborted via a caller-provided AbortSignal. */
-export class HonuaAbortError extends Error {
-    constructor(message = "Request was aborted") {
-        super(message);
+export class HonuaAbortError extends HonuaSdkError {
+    constructor(message = "Request was aborted", options = {}) {
+        super("core.cancelled", message, options);
         this.name = "HonuaAbortError";
     }
 }
 /** Thrown when a gRPC-Web request fails, wrapping the underlying ConnectError. */
-export class HonuaGrpcError extends Error {
+export class HonuaGrpcError extends HonuaSdkError {
     code;
     details;
-    constructor(code, message, details) {
-        super(message);
-        this.name = "HonuaGrpcError";
+    constructor(code, message, details, options = {}) {
+        super(GRPC_RETRYABLE_CODES.has(code) ? "core.grpc.transient" : "core.grpc.rejected", message, {
+            ...options,
+            context: mergeHonuaErrorContext(options.context, { grpcCode: code }),
+        });
         this.code = code;
+        this.name = "HonuaGrpcError";
         this.details = details;
     }
 }
@@ -92,32 +132,58 @@ export class HonuaGrpcError extends Error {
  * decide whether to swap protocols, fall back to a degraded strategy, or
  * surface the limitation to the user.
  */
-export class HonuaCapabilityNotSupportedError extends Error {
+export class HonuaCapabilityNotSupportedError extends HonuaSdkError {
     capability;
     protocol;
     sourceId;
-    constructor(capability, protocol, sourceId) {
-        super(sourceId
+    constructor(capability, protocol, sourceId, options = {}) {
+        const message = sourceId
             ? `Capability "${capability}" is not supported by protocol "${protocol}" on source "${sourceId}"`
-            : `Capability "${capability}" is not supported by protocol "${protocol}"`);
+            : `Capability "${capability}" is not supported by protocol "${protocol}"`;
+        super("core.capability-not-supported", message, {
+            ...options,
+            context: mergeHonuaErrorContext(options.context, { capability, protocol, sourceId }),
+        });
         this.name = "HonuaCapabilityNotSupportedError";
         this.capability = capability;
         this.protocol = protocol;
         this.sourceId = sourceId;
     }
 }
+/**
+ * Thrown by the auth providers (`oauth2`, `clientCredentials`, …) when a
+ * credential cannot be produced. Branch on `.code` (see {@link HonuaAuthErrorCode})
+ * to decide whether to start interactive sign-in, retry the refresh later, or
+ * surface the failure to the user. The underlying transport/parse failure, when
+ * present, is preserved on `.cause`.
+ *
+ * @see [`docs/errors.md`](../../docs/errors.md)
+ */
+export class HonuaAuthError extends HonuaSdkError {
+    code;
+    cause;
+    constructor(code, message, options = {}) {
+        super(AUTH_ERROR_CODES[code], message, options);
+        this.code = code;
+        this.name = "HonuaAuthError";
+        this.cause = options.cause;
+    }
+}
 /**
  * Thrown when an `ExplorationContext` operation is invalid — for example,
  * dispatching an intent against a context that has been disposed, restoring
  * an incompatible snapshot, or binding a view that requests a slice that is
  * not exposed by the current dataset.
  */
-export class HonuaExplorationContextError extends Error {
+export class HonuaExplorationContextError extends HonuaSdkError {
     code;
-    constructor(code, message) {
-        super(message);
-        this.name = "HonuaExplorationContextError";
+    constructor(code, message, options = {}) {
+        super("core.exploration-context", message, {
+            ...options,
+            context: mergeHonuaErrorContext(options.context, { reason: code }),
+        });
         this.code = code;
+        this.name = "HonuaExplorationContextError";
     }
 }
 /**
@@ -128,13 +194,17 @@ export class HonuaExplorationContextError extends Error {
  * `src/core/wfs-capabilities.ts`; raw access lives behind the `protocol("wfs")`
  * escape hatch.
  */
-export class HonuaWfsExceptionError extends Error {
+export class HonuaWfsExceptionError extends HonuaSdkError {
     exceptionCode;
     locator;
-    constructor(exceptionCode, message, locator) {
-        super(locator
+    constructor(exceptionCode, message, locator, options = {}) {
+        const formattedMessage = locator
             ? `WFS ExceptionReport ${exceptionCode} (${locator}): ${message}`
-            : `WFS ExceptionReport ${exceptionCode}: ${message}`);
+            : `WFS ExceptionReport ${exceptionCode}: ${message}`;
+        super("core.wfs-exception", formattedMessage, {
+            ...options,
+            context: mergeHonuaErrorContext(options.context, { exceptionCode, locator }),
+        });
         this.name = "HonuaWfsExceptionError";
         this.exceptionCode = exceptionCode;
         this.locator = locator;
@@ -142,15 +212,12 @@ export class HonuaWfsExceptionError extends Error {
 }
 /** Type guard that narrows any value to one of the Honua SDK error types. */
 export function isHonuaError(error) {
-    return (error instanceof HonuaHttpError ||
-        error instanceof HonuaTimeoutError ||
-        error instanceof HonuaNetworkError ||
-        error instanceof HonuaAbortError ||
-        error instanceof HonuaGrpcError ||
-        error instanceof HonuaCapabilityNotSupportedError ||
-        error instanceof HonuaExplorationContextError ||
-        error instanceof HonuaWfsExceptionError ||
-        error instanceof HonuaJobFailedError ||
-        error instanceof HonuaWmsCapabilitiesParseError ||
-        error instanceof HonuaWmtsCapabilitiesParseError);
+    return isHonuaSdkError(error);
 }
+const HTTP_RETRYABLE_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+const GRPC_RETRYABLE_CODES = new Set([4, 8, 10, 14]);
+const AUTH_ERROR_CODES = {
+    interaction_required: "core.auth.interaction-required",
+    refresh_failed: "core.auth.refresh-failed",
+    invalid_grant: "core.auth.invalid-grant",
+};

package/core/geoparquet-sql.d.ts

@@ -0,0 +1,190 @@
+/**
+ * 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(...)`.
+ * - `geoarrow-point` / `geoarrow-linestring` / `geoarrow-polygon` /
+ *   `geoarrow-multipoint` / `geoarrow-multilinestring` /
+ *   `geoarrow-multipolygon`: GeoParquet **1.1** native single-geometry
+ *   encodings (`geo.columns[].encoding`). DuckDB exposes these as nested
+ *   `STRUCT`/`LIST` columns, not a `GEOMETRY` value — there is no DuckDB
+ *   spatial expression for them. Geometry projection is decoded in JS by
+ *   `@honua/sdk-js/geoparquet`'s native decoder (`native-geometry.ts`, built
+ *   on `src/columnar/geoarrow.ts`); a spatial predicate against one of these
+ *   columns requires a GeoParquet 1.1 bbox-covering column
+ *   ({@link GeometryColumnPlan.bboxColumn}) and otherwise fails closed — see
+ *   {@link geometryExpr}.
+ */
+export type GeometryEncoding = "wkb" | "native" | "geojson" | "geoarrow-point" | "geoarrow-linestring" | "geoarrow-polygon" | "geoarrow-multipoint" | "geoarrow-multilinestring" | "geoarrow-multipolygon";
+/** The `geoarrow-*` subset of {@link GeometryEncoding} (GeoParquet 1.1 native). */
+export type GeoArrowNativeGeometryEncoding = Extract<GeometryEncoding, `geoarrow-${string}`>;
+/** True for a GeoParquet 1.1 native single-geometry encoding (see {@link GeometryEncoding}). */
+export declare function isGeoArrowNativeEncoding(encoding: GeometryEncoding): encoding is GeoArrowNativeGeometryEncoding;
+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;
+    /**
+     * Coordinate dimensions physically stored by a `geoarrow-*` encoding.
+     * Required (and only meaningful) when {@link encoding} is one of the
+     * `geoarrow-*` values; GeoParquet 1.1 native encodings carry no `M`.
+     */
+    readonly nativeDimensions?: "xy" | "xyz";
+}
+/**
+ * SQL expression that yields a DuckDB `GEOMETRY` from the stored geometry
+ * column, adapting to the physical encoding.
+ *
+ * @throws for a `geoarrow-*` encoding — GeoParquet 1.1 native columns are
+ *   nested `STRUCT`/`LIST` values with no DuckDB spatial-predicate
+ *   expression. Callers must fail closed before constructing SQL rather than
+ *   let a malformed `ST_Intersects(...)` reach DuckDB; use a bbox-covering
+ *   column for spatial pushdown and the dedicated native decoder for
+ *   geometry projection instead.
+ */
+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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"}