@honua/react 0.1.0-beta.0 → 0.1.1-beta.0

package/query-planner/diagnostics.js

@@ -0,0 +1,373 @@
+import { sourceSchemaV2EnvelopeFingerprint } from "../contract/schema-envelope.js";
+import { canonicalStringify, sha256, toJsonValue } from "./canonical.js";
+import { HonuaQueryPlanningError, QUERY_PLANNER_VERSION, QUERY_PLAN_DIAGNOSTICS_VERSION } from "./types.js";
+export function createQueryPlanProvenance(descriptor, source, options) {
+    const schema = schemaProvenance(descriptor, options.schemaVersion);
+    const discovery = discoveryProvenance(options.discovery);
+    const endpointFingerprint = digest("endpoint", source.endpoint);
+    const authorizationScope = {
+        fingerprint: digest("authorization-scope", [...source.authorizationScope].sort()),
+        count: source.authorizationScope.length,
+    };
+    const descriptorFingerprint = digest("descriptor", {
+        source,
+        schema,
+    });
+    const versionFingerprint = source.sourceVersion === undefined
+        ? undefined
+        : evidenceFingerprint("source-version", stableText(source.sourceVersion, "sourceVersion"));
+    return {
+        version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+        source: {
+            id: source.id,
+            protocol: source.protocol,
+            endpointFingerprint,
+            descriptorFingerprint,
+            ...(versionFingerprint ? { versionFingerprint } : {}),
+        },
+        schema,
+        discovery,
+        authorizationScope,
+    };
+}
+export function createStepProvenance(provenance) {
+    return {
+        version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+        sourceFingerprint: provenance.source.descriptorFingerprint,
+        ...(provenance.schema.state === "known" ? { schemaFingerprint: provenance.schema.fingerprint } : {}),
+        discoveryFingerprint: provenance.discovery.fingerprint,
+        authorizationScopeFingerprint: provenance.authorizationScope.fingerprint,
+    };
+}
+export function createCacheDecision(options) {
+    const policy = options?.policy ?? "bypass";
+    if (!["bypass", "prefer-cache", "require-fresh"].includes(policy))
+        invalid("cache.policy");
+    if (policy === "bypass") {
+        return {
+            version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+            policy,
+            action: "bypass",
+            freshness: "unknown",
+            reason: "policy-bypass",
+        };
+    }
+    const freshness = options?.freshness ?? "unknown";
+    if (!["fresh", "stale", "unknown"].includes(freshness))
+        invalid("cache.freshness");
+    const validator = options?.validator ? normalizeValidator(options.validator, "cache.validator") : undefined;
+    if (freshness === "fresh") {
+        return {
+            version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+            policy,
+            action: "reuse",
+            freshness,
+            ...(validator ? { validator } : {}),
+            reason: "fresh-entry",
+        };
+    }
+    if (validator) {
+        return {
+            version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+            policy,
+            action: "revalidate",
+            freshness,
+            validator,
+            reason: "validator-available",
+        };
+    }
+    return {
+        version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+        policy,
+        action: "refresh",
+        freshness,
+        reason: freshness === "stale" ? "stale-entry" : "cache-miss",
+    };
+}
+export function createStepDiagnostics(step, estimates, provenance) {
+    const losses = bboxApproximated(step) ? [spatialEnvelopeLoss()] : [];
+    const fidelity = losses.length > 0 ? "approximate" : step.engine === "client" ? "equivalent" : "exact";
+    return {
+        fidelity,
+        losses,
+        bounds: stepBounds(step, estimates),
+        provenance: createStepProvenance(provenance),
+    };
+}
+export function summarizePlanBounds(steps) {
+    return {
+        version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+        requests: summarizeQuantity(steps, "requests", "request"),
+        rows: summarizeQuantity(steps, "rows", "row"),
+        bytes: summarizeQuantity(steps, "bytes", "byte"),
+        transferBytes: summarizeQuantity(steps, "transferBytes", "byte"),
+        serializedMaterializationBytes: summarizeQuantity(steps, "serializedMaterializationBytes", "byte"),
+        memoryBytes: summarizeQuantity(steps, "memoryBytes", "byte"),
+    };
+}
+export function summarizeFidelity(steps) {
+    const fidelity = steps.some((step) => step.fidelity === "approximate")
+        ? "approximate"
+        : steps.some((step) => step.fidelity === "equivalent")
+            ? "equivalent"
+            : "exact";
+    return { fidelity, losses: steps.flatMap((step) => step.losses) };
+}
+export function createPlanWarnings(steps, source) {
+    const warnings = [];
+    if (steps.some((step) => step.engine === "client")) {
+        warnings.push({
+            code: "bounded-local-fallback",
+            severity: "warning",
+            path: "$.steps[1]",
+            message: "Execution uses a bounded local fallback and fails closed if its materialization ceiling is exceeded.",
+            remediation: "Enable server pushdown or reduce the query input bound.",
+        });
+    }
+    if (source.protocol === "ogc-features" && steps.some((step) => step.engine === "client")) {
+        warnings.push({
+            code: "geometry-transfer-required",
+            severity: "warning",
+            path: "$.steps[0].query.returnGeometry",
+            message: "OGC API Features may transfer geometry because portable geometry suppression is unavailable.",
+            remediation: "Use a server projection that omits geometry when the endpoint supports one.",
+        });
+    }
+    if (steps.some(bboxApproximated)) {
+        warnings.push({
+            code: "approximate-spatial-filter",
+            severity: "warning",
+            path: "$.ir.query.spatialFilter",
+            message: "A spatial predicate was reduced to its bounding envelope.",
+            remediation: "Use an envelope query or an exact spatial compiler.",
+        });
+    }
+    return warnings;
+}
+function bboxApproximated(step) {
+    return step.compiled !== undefined && "bboxApproximated" in step.compiled && step.compiled.bboxApproximated === true;
+}
+export function createPlanValidity(ir, provenance, capabilityPolicy, fallback, executionMode) {
+    const unsigned = {
+        version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+        plannerVersion: QUERY_PLANNER_VERSION,
+        contractVersion: `${ir.kind}@${ir.version}`,
+        executionMode,
+        sourceFingerprint: provenance.source.descriptorFingerprint,
+        schemaFingerprint: digest("schema-identity", provenance.schema),
+        discoveryFingerprint: provenance.discovery.fingerprint,
+        authorizationScopeFingerprint: provenance.authorizationScope.fingerprint,
+        queryFingerprint: digest("query", ir.query),
+        crsFingerprint: digest("crs", crsIdentity(ir)),
+        policyFingerprint: digest("policy", { capabilityPolicy, fallback }),
+    };
+    return { ...unsigned, fingerprint: digest("validity", unsigned) };
+}
+function stepBounds(step, estimates) {
+    if (step.engine === "client") {
+        return {
+            version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+            requests: exact("request", 0),
+            rows: step.maxRows === undefined ? unknown("row") : bounded("row", 0, step.maxRows, "fallback-policy"),
+            bytes: step.maxBytes === undefined ? unknown("byte") : bounded("byte", 0, step.maxBytes, "fallback-policy"),
+            transferBytes: exact("byte", 0),
+            serializedMaterializationBytes: step.maxBytes === undefined
+                ? estimates.bytes === undefined
+                    ? unknown("byte")
+                    : estimated("byte", estimates.bytes)
+                : bounded("byte", 0, step.maxBytes, "fallback-policy"),
+            memoryBytes: unknown("byte"),
+        };
+    }
+    const queryLimit = compiledRowLimit(step.compiled) ?? step.query?.pagination?.limit;
+    const queryAll = step.operation === "queryAll";
+    const requests = queryAll
+        ? estimates.requests === undefined
+            ? { ...unknown("request"), lower: 1 }
+            : { ...estimated("request", estimates.requests), lower: 1 }
+        : exact("request", 1);
+    const rows = queryLimit !== undefined
+        ? bounded("row", 0, queryLimit, "query-limit")
+        : estimates.rows === undefined
+            ? unknown("row")
+            : estimated("row", estimates.rows);
+    const bytes = estimates.bytes === undefined ? unknown("byte") : estimated("byte", estimates.bytes);
+    return {
+        version: QUERY_PLAN_DIAGNOSTICS_VERSION,
+        requests,
+        rows,
+        bytes,
+        transferBytes: bytes,
+        serializedMaterializationBytes: exact("byte", 0),
+        memoryBytes: unknown("byte"),
+    };
+}
+function schemaProvenance(descriptor, schemaVersion) {
+    if (descriptor.schemaV2 !== undefined) {
+        try {
+            return {
+                state: "known",
+                fingerprint: sourceSchemaV2EnvelopeFingerprint(descriptor.schemaV2),
+                basis: "schema-v2",
+            };
+        }
+        catch {
+            throw new HonuaQueryPlanningError("invalid-query", "descriptor.schemaV2 identity is invalid");
+        }
+    }
+    if (schemaVersion !== undefined) {
+        return {
+            state: "known",
+            fingerprint: evidenceFingerprint("schema-version", stableText(schemaVersion, "schemaVersion")),
+            basis: "version",
+        };
+    }
+    return { state: "unavailable", reason: "not-provided" };
+}
+function discoveryProvenance(context) {
+    const state = context?.state ?? "unavailable";
+    if (!["metadata", "declared", "inferred", "unavailable"].includes(state))
+        invalid("discovery.state");
+    if (context?.source !== undefined && context.sourceFingerprint !== undefined)
+        invalid("discovery.source");
+    const sourceFingerprint = context?.sourceFingerprint
+        ? verifiedFingerprint(context.sourceFingerprint, "discovery.sourceFingerprint")
+        : context?.source !== undefined
+            ? digest("discovery-source", stableText(context.source, "discovery.source"))
+            : undefined;
+    if (state !== "unavailable" && !sourceFingerprint)
+        invalid("discovery.source");
+    const validator = context?.validator ? normalizeValidator(context.validator, "discovery.validator") : undefined;
+    const unsigned = { state, ...(sourceFingerprint ? { sourceFingerprint } : {}), ...(validator ? { validator } : {}) };
+    return { ...unsigned, fingerprint: digest("discovery", unsigned) };
+}
+function normalizeValidator(input, path) {
+    if (!["etag", "last-modified", "revision", "fingerprint"].includes(input.kind))
+        invalid(`${path}.kind`);
+    if ((input.value === undefined) === (input.fingerprint === undefined))
+        invalid(path);
+    const fingerprint = input.fingerprint
+        ? verifiedFingerprint(input.fingerprint, `${path}.fingerprint`)
+        : digest("validator", { kind: input.kind, value: stableText(input.value, `${path}.value`) });
+    return { kind: input.kind, fingerprint };
+}
+function spatialEnvelopeLoss() {
+    return {
+        code: "spatial-envelope-reduction",
+        path: "$.ir.query.spatialFilter",
+        description: "The source evaluates the input geometry's bounding envelope instead of its exact shape.",
+        remediation: "Use an envelope query or select a compiler with exact geometry predicate support.",
+    };
+}
+function exact(unit, value) {
+    return { unit, confidence: "exact", source: "compiler", lower: value, upper: value, estimate: value };
+}
+function bounded(unit, lower, upper, source) {
+    return { unit, confidence: "bounded", source, lower, upper };
+}
+function estimated(unit, estimate) {
+    return { unit, confidence: "estimated", source: "caller-estimate", estimate };
+}
+function unknown(unit) {
+    return { unit, confidence: "unknown", source: "unavailable" };
+}
+function summarizeQuantity(steps, key, unit) {
+    const quantities = steps.map((step) => step.bounds[key]);
+    if (quantities.length === 0)
+        return unknown(unit);
+    if (quantities.length === 1)
+        return quantities[0];
+    const lower = sumWhenComplete(quantities, "lower");
+    const upper = sumWhenComplete(quantities, "upper");
+    const estimate = sumWhenComplete(quantities, "estimate");
+    const fields = {
+        ...(lower === undefined ? {} : { lower }),
+        ...(upper === undefined ? {} : { upper }),
+        ...(estimate === undefined ? {} : { estimate }),
+    };
+    if (quantities.every((quantity) => quantity.confidence === "exact")) {
+        return { unit, confidence: "exact", source: "plan-summary", ...fields };
+    }
+    if (quantities.some((quantity) => quantity.confidence === "unknown")) {
+        return { unit, confidence: "unknown", source: "plan-summary", ...fields };
+    }
+    if (lower !== undefined && upper !== undefined) {
+        return { unit, confidence: "bounded", source: "plan-summary", ...fields };
+    }
+    if (estimate !== undefined) {
+        return { unit, confidence: "estimated", source: "plan-summary", ...fields };
+    }
+    return { unit, confidence: "unknown", source: "plan-summary", ...fields };
+}
+function sumWhenComplete(quantities, key) {
+    if (quantities.some((quantity) => quantity[key] === undefined))
+        return undefined;
+    const total = quantities.reduce((sum, quantity) => sum + quantity[key], 0);
+    return Number.isFinite(total) ? total : undefined;
+}
+function compiledRowLimit(compiled) {
+    if (!compiled || !("compiler" in compiled))
+        return undefined;
+    const artifact = compiled;
+    const field = artifact.compiler === "ogc-api-features-query-v1"
+        ? "limit"
+        : artifact.compiler === "wfs-2.0-get-feature-v1"
+            ? "count"
+            : artifact.compiler === "odata-v4-query-v1"
+                ? "top"
+                : artifact.compiler === "geoservices-rest-query-v1" || artifact.compiler === "honua-grpc-query-features-v1"
+                    ? "resultRecordCount"
+                    : undefined;
+    if (!field)
+        return undefined;
+    const value = artifact[field];
+    return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function crsIdentity(ir) {
+    const geometry = ir.query.spatialFilter?.geometry;
+    const filterBinding = geometry
+        ? {
+            geometryType: ir.query.spatialFilter?.geometryType,
+            spatialReference: geometry.spatialReference ?? null,
+            crs: geometry.crs ?? null,
+            srsName: geometry.srsName ?? null,
+        }
+        : null;
+    return {
+        sourceSrsName: "srsName" in ir.source ? (ir.source.srsName ?? null) : null,
+        filter: filterBinding,
+        output: ir.query.outSr ?? null,
+        transformPolicy: "no-implicit-transform-v1",
+    };
+}
+function digest(namespace, value) {
+    return sha256(`${namespace}:v1:${canonicalStringify(toJsonValue(value))}`);
+}
+function verifiedFingerprint(value, path) {
+    if (!/^sha256:[0-9a-f]{64}$/.test(value))
+        invalid(path);
+    return value;
+}
+function evidenceFingerprint(namespace, value) {
+    return /^sha256:[0-9a-f]{64}$/.test(value) ? value : digest(namespace, value);
+}
+function stableText(value, path) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        new TextEncoder().encode(value).byteLength > 4_096 ||
+        containsControlCharacter(value)) {
+        invalid(path);
+    }
+    return value;
+}
+function containsControlCharacter(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code <= 0x1f || code === 0x7f)
+            return true;
+    }
+    return false;
+}
+function invalid(path) {
+    throw new HonuaQueryPlanningError("invalid-query", `${path} is invalid`);
+}

package/query-planner/duckdb.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Compile canonical query IR to deterministic DuckDB SQL over
+ * `read_parquet(...)` for the GeoParquet columnar `Source`, without performing
+ * any network, filesystem, or DuckDB metadata I/O.
+ *
+ * The heavy lifting — identifier/literal escaping, spatial predicate pushdown,
+ * GeoJSON projection, and GROUP BY aggregation — is delegated to the
+ * dependency-free {@link module:core/geoparquet-sql} SQL builder that the live
+ * GeoParquet `Source` already uses, so the planner and the adapter emit the
+ * exact same SQL for the same inputs.
+ *
+ * @module
+ */
+import type { ExecutableCrsBinding, SourceSchemaV2 } from "../contract/schema.js";
+import type { GeoParquetResourceHandleV1 } from "./resource.js";
+import { type SemanticCompilationResult, type SemanticSqlParameter } from "./semantic-compiler.js";
+import type { SemanticQuery, SourceSpatiality } from "./semantic-types.js";
+import type { CanonicalQuery, DuckDbCompiledQueryV1, DuckDbCompiledQueryV2, DuckDbGeometryEncoding, QueryIrSourceIdentity, QueryIrSourceIdentityV2 } from "./types.js";
+/** Physical GeoParquet geometry metadata required by the semantic compiler. */
+export interface SemanticDuckDbGeometrySource {
+    /** Logical SourceSchemaV2 field carrying the physical geometry column path. */
+    readonly field: string;
+    readonly encoding: DuckDbGeometryEncoding;
+    /** Optional GeoParquet 1.1 bbox-covering struct column. */
+    readonly bboxColumn?: string;
+}
+/** Pure, credential-free inputs for semantic DuckDB compilation. */
+export interface SemanticDuckDbCompileOptions<TRecord = Record<string, unknown>, TSpatiality extends SourceSpatiality = SourceSpatiality> {
+    readonly query: SemanticQuery<TRecord, "geoparquet", TSpatiality>;
+    readonly schema: SourceSchemaV2;
+    readonly resource: GeoParquetResourceHandleV1;
+    readonly geometry?: SemanticDuckDbGeometrySource;
+    /** Exact by default; bbox reduction is opt-in and always reported as approximate. */
+    readonly spatialStrategy?: "exact" | "bbox-envelope";
+}
+export interface SemanticDuckDbSpatialCompilation {
+    readonly path: string;
+    readonly field: string;
+    readonly encoding: DuckDbGeometryEncoding;
+    readonly strategy: "exact" | "bbox-envelope";
+    readonly crs: ExecutableCrsBinding;
+}
+/** Traceable geometry contract for rows returned by the compiled SELECT. */
+export interface SemanticDuckDbOutputGeometry {
+    readonly sourceField: string;
+    readonly sourceEncoding: DuckDbGeometryEncoding;
+    readonly resultField: "geometry";
+    readonly resultEncoding: "geojson";
+    readonly crs: ExecutableCrsBinding;
+    readonly layout: "xy" | "xyz";
+}
+/** Parameterized DuckDB artifact over an opaque #587 resource handle. */
+export interface SemanticDuckDbCompiledQueryV1 {
+    readonly compiler: "duckdb-semantic-query-v1";
+    readonly dialect: "duckdb-sql";
+    readonly schemaFingerprint: SourceSchemaV2["fingerprint"];
+    readonly queryFingerprint: `sha256:${string}`;
+    readonly resource: GeoParquetResourceHandleV1;
+    readonly sqlTemplate: string;
+    readonly parameters: readonly SemanticSqlParameter[];
+    readonly outputGeometry?: SemanticDuckDbOutputGeometry;
+    readonly spatial: readonly SemanticDuckDbSpatialCompilation[];
+    readonly usesNativeFilter: boolean;
+}
+/**
+ * Compile canonical query IR to a deterministic DuckDB `SELECT`. Reuses the
+ * GeoParquet `Source` SQL builder, so the compiled SQL is byte-identical to
+ * what the live adapter runs for the same descriptor + query.
+ */
+export declare function compileDuckDbQuery(source: QueryIrSourceIdentity, query: CanonicalQuery): DuckDbCompiledQueryV1;
+/** Compile a credential-free template; execution recompiles with ephemeral resolved sources. */
+export declare function compileDuckDbQueryV2(source: QueryIrSourceIdentityV2, query: CanonicalQuery): DuckDbCompiledQueryV2;
+/**
+ * Compile the schema-validated semantic AST into parameterized DuckDB SQL.
+ * The table address remains the fixed opaque-resource placeholder; only a
+ * trusted execution boundary may resolve the attached handle to raw locators.
+ */
+export declare function compileSemanticDuckDbQuery<TRecord, TSpatiality extends SourceSpatiality>(options: SemanticDuckDbCompileOptions<TRecord, TSpatiality>): SemanticCompilationResult<SemanticDuckDbCompiledQueryV1>;
+//# sourceMappingURL=duckdb.d.ts.map

package/query-planner/duckdb.d.ts.map

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