@honua/app-platform 0.0.20-alpha.0

package/contract/source.d.ts

@@ -0,0 +1,447 @@
+/**
+ * Built-in `Source` adapters that wrap the runtime classes in
+ * `src/core/surfaces.ts` (`HonuaFeatureLayer`, `HonuaMapLayer`,
+ * `HonuaOgcFeatureCollection`) and the OGC / STAC / WFS / WMS / OData
+ * adapters in `src/core/`. Consumers register adapters for any other
+ * protocol (MapLibre-native sources, etc.) via
+ * `CreateDatasetOptions.resolveSource`.
+ *
+ * These adapters do not reimplement query logic — they translate the
+ * canonical `Query` / `Result` envelope to and from the existing per-class
+ * request and response shapes.
+ *
+ * @module
+ */
+import type { HonuaClient } from "../core/client.js";
+import { HonuaOdataEntitySet } from "../core/odata.js";
+import { HonuaOgcCollectionMap, HonuaOgcMaps } from "../core/ogc-maps.js";
+import type { HonuaOgcProcesses } from "../core/ogc-processes.js";
+import { HonuaOgcRecordCollection } from "../core/ogc-records.js";
+import { HonuaOgcTiles, HonuaOgcTileset } from "../core/ogc-tiles.js";
+import { HonuaStacSearch } from "../core/stac.js";
+import { HonuaFeatureLayer, HonuaGeometryService, HonuaGeoprocessingService, HonuaImageService, HonuaMapLayer, HonuaMapService, HonuaOgcFeatureCollection } from "../core/surfaces.js";
+import { HonuaWfsFeatureType } from "../core/wfs.js";
+import { HonuaWms, HonuaWmsLayer } from "../core/wms.js";
+import { HonuaWmts, HonuaWmtsLayer, HonuaWmtsTileset } from "../core/wmts.js";
+import { HonuaPmtilesArchive } from "./pmtiles.js";
+import { type Capability, type CapabilityPolicy, type CreateDatasetOptions, type Dataset, type Protocol, type Source, type SourceDescriptor } from "./types.js";
+/**
+ * Construct a protocol-neutral `Dataset` over a `HonuaClient`.
+ *
+ * A `Dataset` groups one or more `Source`s. Each `Source` accepts a protocol-neutral
+ * `Query` and returns a protocol-neutral `Result`. The dataset is the cross-protocol
+ * unit of work: a single `Dataset` can mix GeoServices FeatureServer, OGC API Features,
+ * WFS, STAC, and OData sources under one capability policy.
+ *
+ * `Source` handles are constructed lazily, server compatibility is checked once per
+ * dataset (and cached on the underlying client), and capability gaps surface as
+ * {@link HonuaCapabilityNotSupportedError} under the default `"strict"` policy rather
+ * than silently returning empty results.
+ *
+ * Operations the canonical surface does not cover stay reachable through the typed
+ * `source.protocol(...)` escape hatch (e.g. ImageServer `exportImage`, GeometryServer
+ * `project`, GPServer `submitJob`, WFS `LockFeature`).
+ *
+ * @param options - The dataset id, the `HonuaClient` to talk to, the list of
+ *   `SourceDescriptor`s, and (optionally) `capabilityPolicy` and a custom
+ *   `resolveSource` factory.
+ *
+ * @example
+ * ```ts
+ * import { createDataset, PROTOCOL_DEFAULT_CAPABILITIES } from "@honua/sdk-js/contract";
+ * import { HonuaClient } from "@honua/sdk-js/honua";
+ *
+ * const client = new HonuaClient({ baseUrl: "https://your-honua-server.example" });
+ *
+ * const dataset = createDataset({
+ *   id: "parcels",
+ *   client,
+ *   sources: [
+ *     {
+ *       id: "parcels-fs",
+ *       protocol: "geoservices-feature-service",
+ *       locator: { url: "https://your-honua-server.example", serviceId: "parcels", layerId: 0 },
+ *       capabilities: PROTOCOL_DEFAULT_CAPABILITIES["geoservices-feature-service"],
+ *     },
+ *   ],
+ * });
+ *
+ * const parcels = dataset.source("parcels-fs")!;
+ * const result = await parcels.queryAll({
+ *   where: "STATUS = 'ACTIVE'",
+ *   outFields: ["OBJECTID", "NAME"],
+ *   returnGeometry: true,
+ *   pagination: { limit: 500 },
+ * });
+ *
+ * console.log(`Loaded ${result.features.length} features`);
+ * ```
+ */
+export declare function createDataset(options: CreateDatasetOptions): Dataset;
+/**
+ * Adapter factory for a GeoServices FeatureServer layer.
+ *
+ * Used internally by {@link createDataset} when it sees a descriptor with
+ * `protocol: "geoservices-feature-service"`. Calling it directly is rarely
+ * necessary; pass the descriptor to `createDataset` instead.
+ *
+ * @example
+ * ```ts
+ * const dataset = createDataset({
+ *   id: "parcels",
+ *   client,
+ *   sources: [{
+ *     id: "parcels-fs",
+ *     protocol: "geoservices-feature-service",
+ *     locator: { url: "https://your-honua-server.example", serviceId: "parcels", layerId: 0 },
+ *     capabilities: PROTOCOL_DEFAULT_CAPABILITIES["geoservices-feature-service"],
+ *   }],
+ * });
+ * const result = await dataset.source("parcels-fs")!.queryAll({
+ *   where: "STATUS = 'ACTIVE'",
+ *   outFields: ["OBJECTID", "NAME"],
+ * });
+ * ```
+ */
+export declare function geoServicesFeatureSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Adapter factory for a GeoServices MapServer layer.
+ *
+ * Reach `Source.protocol("geoservices-map-service")` for raw `exportImage` /
+ * `identify` / `find` access; the canonical `query()` runs against a single
+ * sublayer via the MapServer query endpoint.
+ *
+ * @example
+ * ```ts
+ * const dataset = createDataset({
+ *   id: "basemap",
+ *   client,
+ *   sources: [{
+ *     id: "states-mapserver",
+ *     protocol: "geoservices-map-service",
+ *     locator: { url: "https://your-honua-server.example", serviceId: "states", layerId: 0 },
+ *     capabilities: PROTOCOL_DEFAULT_CAPABILITIES["geoservices-map-service"],
+ *   }],
+ * });
+ * ```
+ */
+export declare function geoServicesMapServiceSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Adapter factory for an OGC API Features collection.
+ *
+ * @example
+ * ```ts
+ * const dataset = createDataset({
+ *   id: "addresses",
+ *   client,
+ *   sources: [{
+ *     id: "addresses-ogc",
+ *     protocol: "ogc-features",
+ *     locator: { url: "https://your-honua-server.example", collectionId: "addresses" },
+ *     capabilities: PROTOCOL_DEFAULT_CAPABILITIES["ogc-features"],
+ *   }],
+ * });
+ * const result = await dataset.source("addresses-ogc")!.queryAll({
+ *   where: "city = 'Honolulu'",
+ *   pagination: { limit: 200 },
+ * });
+ * ```
+ */
+export declare function ogcFeaturesSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Build a `Source` over an Esri-style ImageServer endpoint. The query
+ * surface drives the raster catalog (each row is a raster with footprint
+ * geometry); image export, identify, and tile operations live behind
+ * `Source.protocol("geoservices-image-service")`.
+ *
+ * @example
+ * ```ts
+ * const dataset = createDataset({
+ *   id: "imagery",
+ *   client,
+ *   sources: [{
+ *     id: "naip",
+ *     protocol: "geoservices-image-service",
+ *     locator: { url: "https://your-honua-server.example", serviceId: "naip" },
+ *     capabilities: PROTOCOL_DEFAULT_CAPABILITIES["geoservices-image-service"],
+ *   }],
+ * });
+ * const img = dataset.source("naip")!.protocol("geoservices-image-service");
+ * const png = await img?.exportImage({ bbox: [-158.5, 21.2, -157.6, 21.7], size: [512, 512] });
+ * ```
+ */
+export declare function geoServicesImageSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Build a `Source` over an Esri-style Geometry Service endpoint. Geometry
+ * Service is a stateless utility — it does not host features — so the
+ * query family throws `HonuaCapabilityNotSupportedError` and operations
+ * (buffer, project, simplify, etc.) live behind
+ * `Source.protocol("geoservices-geometry-service")`.
+ *
+ * @example
+ * ```ts
+ * const geom = dataset.source("geom")!.protocol("geoservices-geometry-service");
+ * const projected = await geom?.project({
+ *   inSr: 4326,
+ *   outSr: 3857,
+ *   geometries: [{ x: -158, y: 21 }],
+ * });
+ * ```
+ */
+export declare function geoServicesGeometryServiceSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Build a `Source` over an Esri-style GP (geoprocessing) service. GP
+ * services run async tasks rather than hosting features; the canonical
+ * feature surface throws and task submission / status / result lookup
+ * live behind `Source.protocol("geoservices-gp-service")`.
+ *
+ * @example
+ * ```ts
+ * const gp = dataset.source("buffer-task")!.protocol("geoservices-gp-service");
+ * const job = await gp!.submitJob({ inputs: { distance: 500 } });
+ * const result = await gp!.awaitJobResult(job.jobId);
+ * ```
+ */
+export declare function geoServicesGPServiceSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Render-only Source adapter for OGC API Tiles. The query family throws
+ * `HonuaCapabilityNotSupportedError` (the conformance class is
+ * tile-fetch, not feature-query); rendering integrations consume the
+ * tileset through `Source.protocol("ogc-tiles")` to reach the underlying
+ * runtime class.
+ *
+ * @example
+ * ```ts
+ * const tiles = dataset.source("ogc-tileset")!.protocol("ogc-tiles");
+ * const bytes = await tiles!.tile({ tileMatrix: "WebMercatorQuad", tileRow: 5, tileCol: 8 });
+ * ```
+ */
+export declare function ogcTilesSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Tiles-only Source adapter for a PMTiles archive (`protocol: "pmtiles"`).
+ *
+ * PMTiles archives are immutable single-file tile stores, so the canonical
+ * query family throws `HonuaCapabilityNotSupportedError` (there is no
+ * feature-query surface on an archive). Archive metadata — bounds, min/max
+ * zoom, and vector layer names — is inspected through the typed escape hatch:
+ * `Source.protocol("pmtiles").describe()`. Rendering integrations register the
+ * `pmtiles://` protocol on the map (see `@honua/sdk-js/runtime`) and reference
+ * the archive as a MapLibre source `url`.
+ *
+ * `locator.url` may carry a leading `pmtiles://` scheme (the MapLibre form) or
+ * be a bare archive URL; both resolve to the same archive.
+ *
+ * @example
+ * ```ts
+ * const archive = dataset.source("basemap")!.protocol("pmtiles");
+ * const info = await archive!.describe();
+ * console.log(info.bounds, info.vectorLayers.map((layer) => layer.id));
+ * ```
+ */
+export declare function pmtilesSource<T>(descriptor: SourceDescriptor, _client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Render-only Source adapter for OGC API Maps. Same shape as the Tiles
+ * adapter — `Source.protocol("ogc-maps")` exposes the runtime class for
+ * server-rendered map images; the canonical query family throws.
+ *
+ * @example
+ * ```ts
+ * const maps = dataset.source("ogc-map")!.protocol("ogc-maps");
+ * const png = await maps!.map({ bbox: [-158, 21, -157, 22], width: 512, height: 512 });
+ * ```
+ */
+export declare function ogcMapsSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Metadata-catalog Source adapter for OGC API Records. The canonical query
+ * family searches one catalog (`locator.collectionId`, the Records
+ * collection/catalog id) and returns record documents as typed features.
+ * Records-specific search affordances (`q`, `type`, `externalIds`,
+ * `profile`, raw HTML/JSON access) live on `Source.protocol("ogc-records")`.
+ *
+ * @example
+ * ```ts
+ * const records = dataset.source("catalog")!;
+ * const result = await records.query({ where: "type = 'dataset' AND q = 'parcels'" });
+ * ```
+ */
+export declare function ogcRecordsSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * `Source` adapter for first-party WMS 1.3.0 services. The render path
+ * routes through `HonuaWms` / `HonuaWmsLayer` (both of which sit
+ * behind the canonical `Source.protocol("wms" | "wms-layer")` escape
+ * hatch); `Source.query()` translates a point spatial filter into a
+ * `GetFeatureInfo` call. Non-point queries throw
+ * `HonuaCapabilityNotSupportedError` so the canonical query envelope
+ * stays honest — multi-pixel feature info lives on
+ * `Source.protocol("wms").featureInfo()`.
+ */
+/**
+ * Adapter factory for a WMS 1.3.0 endpoint.
+ *
+ * The canonical `Source.query()` is implemented through point-only
+ * `GetFeatureInfo`. Reach `Source.protocol("wms")` for raw `GetMap` /
+ * `GetLegendGraphic` access (with TIME / ELEVATION dimension handling and
+ * CRS axis-order swap per WMS 1.3 §6.7.3.2).
+ *
+ * @example
+ * ```ts
+ * const wms = dataset.source("usgs-imagery")!.protocol("wms");
+ * const png = await wms!.getMap({
+ *   layers: ["topo"], bbox: [-158, 21, -157, 22], crs: "EPSG:4326",
+ *   width: 512, height: 512,
+ * });
+ * ```
+ */
+export declare function wmsSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Render-only `Source` adapter for first-party WMTS 1.0.0 services.
+ * `Source.query()` throws because WMTS GetFeatureInfo is keyed on tile
+ * pixels (not a canonical spatial filter); raw access lives on
+ * `Source.protocol("wmts" | "wmts-layer" | "wmts-tileset")`.
+ */
+/**
+ * Adapter factory for a WMTS 1.0.0 endpoint. Render-only; `Source.query()`
+ * throws `HonuaCapabilityNotSupportedError`. Reach `Source.protocol("wmts")`
+ * for RESTful + KVP tile fetch and capabilities.
+ *
+ * @example
+ * ```ts
+ * const wmts = dataset.source("basemap-tiles")!.protocol("wmts");
+ * const tile = await wmts!.tile({ tileMatrixSet: "WebMercatorQuad", tileMatrix: "8", tileRow: 5, tileCol: 8 });
+ * ```
+ */
+export declare function wmtsSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Adapter factory for a STAC API search endpoint.
+ *
+ * The canonical `Source.query()` runs a `POST /search` against the STAC root,
+ * with `Query.spatialFilter` (e.g. an `envelope(...)` bounding box) and
+ * `Query.where` translated into STAC's `bbox` / `datetime` / `filter`
+ * parameters.
+ *
+ * @example
+ * ```ts
+ * import { envelope } from "@honua/sdk-js";
+ *
+ * const dataset = createDataset({
+ *   id: "imagery",
+ *   client,
+ *   sources: [{
+ *     id: "stac-search",
+ *     protocol: "stac",
+ *     locator: { url: "https://your-honua-server.example/stac" },
+ *     capabilities: PROTOCOL_DEFAULT_CAPABILITIES.stac,
+ *   }],
+ * });
+ * const result = await dataset.source("stac-search")!.query({
+ *   where: "collections IN ('landsat-c2-l2')",
+ *   spatialFilter: envelope(-158.5, 21.2, -157.6, 21.7),
+ * });
+ * ```
+ */
+export declare function stacSearchSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Adapter factory for a WFS 2.0 endpoint.
+ *
+ * `Query.where` and `Query.spatialFilter` compile to FES 2.0; GeoJSON is
+ * preferred over GML via `OperationsMetadata` negotiation. `applyEdits()`
+ * builds `<wfs:Transaction>` bodies. Reach `Source.protocol("wfs")` for raw
+ * GML / `LockFeature` / stored-query access.
+ *
+ * @example
+ * ```ts
+ * const dataset = createDataset({
+ *   id: "wfs-parcels",
+ *   client,
+ *   sources: [{
+ *     id: "parcels",
+ *     protocol: "wfs",
+ *     locator: { url: "https://your-honua-server.example/wfs", typeName: "ns:Parcels" },
+ *     capabilities: PROTOCOL_DEFAULT_CAPABILITIES.wfs,
+ *   }],
+ * });
+ * const result = await dataset.source("parcels")!.queryAll({
+ *   where: "STATUS = 'ACTIVE'",
+ *   pagination: { limit: 500 },
+ * });
+ * ```
+ */
+export declare function wfsSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Build a `Source` over an OData v4 entity set. The `Query` translation
+ * lowers `where` / `outFields` / `orderBy` / pagination / spatial filter
+ * onto OData's `$`-prefixed query options. Dialect-specific operations
+ * (`$batch`, `$apply`, `$search`, `$deltatoken`) live behind
+ * `Source.protocol("odata")` on the returned `HonuaOdataEntitySet`.
+ *
+ * `$metadata` is fetched lazily on the first call that needs it and
+ * cached on the entity-set instance. The fetched capability annotations
+ * are intersected with the descriptor's declared `Capabilities` set the
+ * first time a capability-gated method is invoked — this is the
+ * precedent for the metadata-driven downgrade pattern referenced in
+ * `docs/shared-client-contract.md`.
+ */
+/**
+ * Adapter factory for an OData v4 entity set.
+ *
+ * `Query.where` compiles to OData `$filter`, `Query.outFields` becomes
+ * `$select`, `Query.orderBy` becomes `$orderby`, and `Query.pagination`
+ * becomes `$top`/`$skip`. Geospatial filters translate to OData's
+ * `geo.intersects` / `geo.distance` family.
+ *
+ * @example
+ * ```ts
+ * const dataset = createDataset({
+ *   id: "incidents",
+ *   client,
+ *   sources: [{
+ *     id: "incidents",
+ *     protocol: "odata",
+ *     locator: { url: "https://your-honua-server.example/odata", entitySet: "Incidents" },
+ *     capabilities: PROTOCOL_DEFAULT_CAPABILITIES.odata,
+ *   }],
+ * });
+ * const result = await dataset.source("incidents")!.queryAll({
+ *   where: "Severity ge 3",
+ *   orderBy: [{ field: "ReportedAt", direction: "desc" }],
+ *   pagination: { limit: 100 },
+ * });
+ * ```
+ */
+export declare function odataSource<T>(descriptor: SourceDescriptor, client: HonuaClient, policy: CapabilityPolicy): Source<T>;
+/**
+ * Declare the shipped adapter → runtime-class bindings so
+ * `Source.adapter("geoservices-feature-service")` et al. narrow to the
+ * right class instead of collapsing to `unknown`. Downstream adapter
+ * tickets that ship outside this module add their own augmentations in
+ * their own modules.
+ */
+declare module "./types.js" {
+    interface AdapterTypeMap {
+        "geoservices-feature-service": HonuaFeatureLayer;
+        "geoservices-map-service": HonuaMapService;
+        "geoservices-map-layer": HonuaMapLayer;
+        "geoservices-image-service": HonuaImageService;
+        "geoservices-geometry-service": HonuaGeometryService;
+        "geoservices-gp-service": HonuaGeoprocessingService;
+        "ogc-features": HonuaOgcFeatureCollection;
+        "ogc-tiles": HonuaOgcTileset | HonuaOgcTiles;
+        "ogc-maps": HonuaOgcMaps | HonuaOgcCollectionMap;
+        "ogc-records": HonuaOgcRecordCollection;
+        "ogc-processes": HonuaOgcProcesses;
+        stac: HonuaStacSearch;
+        wfs: HonuaWfsFeatureType;
+        wms: HonuaWms;
+        "wms-layer": HonuaWmsLayer;
+        wmts: HonuaWmts;
+        "wmts-layer": HonuaWmtsLayer;
+        "wmts-tileset": HonuaWmtsTileset;
+        odata: HonuaOdataEntitySet;
+        pmtiles: HonuaPmtilesArchive;
+    }
+}
+/** Sentinel: `Capabilities` set that contains every defined capability. */
+export declare const ALL_CAPABILITIES: ReadonlySet<Capability>;
+/** Tag a `Protocol` as "first-party-supported by this build". */
+export declare const FIRST_PARTY_PROTOCOLS: ReadonlySet<Protocol>;
+//# sourceMappingURL=source.d.ts.map

package/contract/source.d.ts.map

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