@haybarn/node-api 1.5.5-rc1 → 2.0.0-rc3

package/lib/DuckDBTypeId.d.ts

@@ -38,5 +38,8 @@ export declare enum DuckDBTypeId {
     SQLNULL = 36,
     STRING_LITERAL = 37,
     INTEGER_LITERAL = 38,
-    TIME_NS = 39
+    TIME_NS = 39,
+    GEOMETRY = 40,
+    VARIANT = 41,
+    TIMESTAMP_TZ_NS = 42
 }

package/lib/DuckDBTypeId.js

@@ -44,4 +44,7 @@ var DuckDBTypeId;
     DuckDBTypeId[DuckDBTypeId["STRING_LITERAL"] = 37] = "STRING_LITERAL";
     DuckDBTypeId[DuckDBTypeId["INTEGER_LITERAL"] = 38] = "INTEGER_LITERAL";
     DuckDBTypeId[DuckDBTypeId["TIME_NS"] = 39] = "TIME_NS";
+    DuckDBTypeId[DuckDBTypeId["GEOMETRY"] = 40] = "GEOMETRY";
+    DuckDBTypeId[DuckDBTypeId["VARIANT"] = 41] = "VARIANT";
+    DuckDBTypeId[DuckDBTypeId["TIMESTAMP_TZ_NS"] = 42] = "TIMESTAMP_TZ_NS";
 })(DuckDBTypeId || (exports.DuckDBTypeId = DuckDBTypeId = {}));

package/lib/DuckDBValueConverter.d.ts

@@ -1,3 +1,13 @@
 import { DuckDBType } from './DuckDBType';
 import { DuckDBValue } from './values';
 export type DuckDBValueConverter<T> = (value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>) => T | null;
+/**
+ * A converter for a single DuckDB type id, whose output type is narrower than
+ * the output type of the top-level converter it recurses through.
+ *
+ * `DuckDBValueConverter<T>` ties both the return type and the recursion hook
+ * to the same `T`. In a per-type-id converter map, only the return type varies
+ * by id: the `converter` argument is always the map's top-level converter, so
+ * `Nested` stays fixed while `Out` narrows.
+ */
+export type DuckDBValueConverterFor<Out, Nested> = (value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<Nested>) => Out | null;

package/lib/DuckDBValueConverters.d.ts

@@ -10,8 +10,10 @@ export declare function bigintFromBigIntValue(value: DuckDBValue, type: DuckDBTy
 export declare function stringFromValue(value: DuckDBValue): string;
 export declare function bytesFromBlobValue(value: DuckDBValue): Uint8Array;
 export declare function bytesFromBitValue(value: DuckDBValue): Uint8Array;
+export declare function bytesFromGeometryValue(value: DuckDBValue): Uint8Array;
 export declare function dateFromDateValue(value: DuckDBValue): Date;
 export declare function bigintFromTimeValue(value: DuckDBValue): bigint;
+export declare function bigintFromTimeNSValue(value: DuckDBValue): bigint;
 export declare function dateFromTimestampValue(value: DuckDBValue): Date;
 export declare function dateFromTimestampSecondsValue(value: DuckDBValue): Date;
 export declare function dateFromTimestampMillisecondsValue(value: DuckDBValue): Date;
@@ -21,6 +23,7 @@ export declare function objectFromTimeTZValue(value: DuckDBValue): {
     offset: number;
 };
 export declare function dateFromTimestampTZValue(value: DuckDBValue): Date;
+export declare function dateFromTimestampTZNanosecondsValue(value: DuckDBValue): Date;
 export declare function objectFromIntervalValue(value: DuckDBValue): {
     months: number;
     days: number;
@@ -36,6 +39,14 @@ export declare function arrayFromListValue<T>(value: DuckDBValue, type: DuckDBTy
 export declare function objectFromStructValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): {
     [key: string]: T | null;
 };
+export declare function arrayFromTupleValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): (T | null)[];
+/**
+ * Converts a STRUCT value: a tuple (see `DuckDBStructType.isTuple`) to an
+ * array of its items, and a named struct to an object keyed by entry name.
+ */
+export declare function objectOrArrayFromStructValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): {
+    [key: string]: T | null;
+} | (T | null)[];
 export declare function objectArrayFromMapValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): {
     key: T | null;
     value: T | null;
@@ -45,3 +56,19 @@ export declare function objectFromUnionValue<T>(value: DuckDBValue, type: DuckDB
     tag: string;
     value: T | null;
 };
+/**
+ * Converter for VARIANT values: unwraps the `DuckDBVariantValue` wrapper
+ * and recursively walks the inner value, re-dispatching each scalar leaf
+ * through the supplied converter.
+ *
+ * A walker is needed (rather than just dispatching through the converter)
+ * because VARIANT containers are *heterogeneous* — items in a list or
+ * fields in a struct can have different types — while
+ * `arrayFromListValue` / `objectFromStructValue` / `objectArrayFromMapValue`
+ * assume a homogeneous element type pulled from the enclosing
+ * `DuckDBListType` / `DuckDBStructType` / `DuckDBMapType`. The walker
+ * emits the same output shape those converters do, and prefers the
+ * `DuckDBVariantValue.type` recorded by the decoder over `typeForValue`
+ * inference whenever a wrapper is encountered.
+ */
+export declare function fromVariantValue<T>(value: DuckDBValue, _type: DuckDBType, converter: DuckDBValueConverter<T>): T | null;

package/lib/DuckDBValueConverters.js

@@ -9,29 +9,42 @@ exports.bigintFromBigIntValue = bigintFromBigIntValue;
 exports.stringFromValue = stringFromValue;
 exports.bytesFromBlobValue = bytesFromBlobValue;
 exports.bytesFromBitValue = bytesFromBitValue;
+exports.bytesFromGeometryValue = bytesFromGeometryValue;
 exports.dateFromDateValue = dateFromDateValue;
 exports.bigintFromTimeValue = bigintFromTimeValue;
+exports.bigintFromTimeNSValue = bigintFromTimeNSValue;
 exports.dateFromTimestampValue = dateFromTimestampValue;
 exports.dateFromTimestampSecondsValue = dateFromTimestampSecondsValue;
 exports.dateFromTimestampMillisecondsValue = dateFromTimestampMillisecondsValue;
 exports.dateFromTimestampNanosecondsValue = dateFromTimestampNanosecondsValue;
 exports.objectFromTimeTZValue = objectFromTimeTZValue;
 exports.dateFromTimestampTZValue = dateFromTimestampTZValue;
+exports.dateFromTimestampTZNanosecondsValue = dateFromTimestampTZNanosecondsValue;
 exports.objectFromIntervalValue = objectFromIntervalValue;
 exports.jsonObjectFromIntervalValue = jsonObjectFromIntervalValue;
 exports.doubleFromDecimalValue = doubleFromDecimalValue;
 exports.arrayFromListValue = arrayFromListValue;
 exports.objectFromStructValue = objectFromStructValue;
+exports.arrayFromTupleValue = arrayFromTupleValue;
+exports.objectOrArrayFromStructValue = objectOrArrayFromStructValue;
 exports.objectArrayFromMapValue = objectArrayFromMapValue;
 exports.arrayFromArrayValue = arrayFromArrayValue;
 exports.objectFromUnionValue = objectFromUnionValue;
+exports.fromVariantValue = fromVariantValue;
 const DuckDBType_1 = require("./DuckDBType");
+const DuckDBTypeId_1 = require("./DuckDBTypeId");
+const typeForValue_1 = require("./typeForValue");
 const values_1 = require("./values");
 const MIN_DATE_DAYS = -100000000;
 const MAX_DATE_DAYS = 100000000;
 //                      -8640000000000
 const MIN_DATE_MILLIS = -8640000000000000;
 const MAX_DATE_MILLIS = 8640000000000000;
+/** Whether a TIMESTAMP_NS or TIMESTAMPTZ_NS value is not +/-infinity. */
+function isFiniteNanos(nanos) {
+    return (nanos !== values_1.DuckDBTimestampNanosecondsValue.PosInf.nanos &&
+        nanos !== values_1.DuckDBTimestampNanosecondsValue.NegInf.nanos);
+}
 const MILLS_PER_DAY = 24 * 60 * 60 * 1000;
 function unsupportedConverter(_, type) {
     throw new Error(`Unsupported type: ${type}`);
@@ -72,6 +85,12 @@ function bytesFromBitValue(value) {
     }
     throw new Error(`Expected DuckDBBitValue`);
 }
+function bytesFromGeometryValue(value) {
+    if (value instanceof values_1.DuckDBGeometryValue) {
+        return value.bytes;
+    }
+    throw new Error(`Expected DuckDBGeometryValue`);
+}
 function dateFromDateValue(value) {
     if (value instanceof values_1.DuckDBDateValue) {
         if (MIN_DATE_DAYS <= value.days && value.days <= MAX_DATE_DAYS) {
@@ -87,6 +106,12 @@ function bigintFromTimeValue(value) {
     }
     throw new Error(`Expected DuckDBTimeValue`);
 }
+function bigintFromTimeNSValue(value) {
+    if (value instanceof values_1.DuckDBTimeNSValue) {
+        return value.nanos;
+    }
+    throw new Error(`Expected DuckDBTimeNSValue`);
+}
 function dateFromTimestampValue(value) {
     if (value instanceof values_1.DuckDBTimestampValue) {
         const millis = value.micros / 1000n;
@@ -120,7 +145,9 @@ function dateFromTimestampMillisecondsValue(value) {
 function dateFromTimestampNanosecondsValue(value) {
     if (value instanceof values_1.DuckDBTimestampNanosecondsValue) {
         const millis = value.nanos / 1000000n;
-        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+        if (isFiniteNanos(value.nanos) &&
+            MIN_DATE_MILLIS <= millis &&
+            millis <= MAX_DATE_MILLIS) {
             return new Date(Number(millis));
         }
         throw new Error(`TIMESTAMP_NS value out of range for JS Date: ${value.nanos} nanos`);
@@ -146,6 +173,18 @@ function dateFromTimestampTZValue(value) {
     }
     throw new Error(`Expected DuckDBTimestampTZValue`);
 }
+function dateFromTimestampTZNanosecondsValue(value) {
+    if (value instanceof values_1.DuckDBTimestampTZNanosecondsValue) {
+        const millis = value.nanos / 1000000n;
+        if (isFiniteNanos(value.nanos) &&
+            MIN_DATE_MILLIS <= millis &&
+            millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMP_TZ_NS value out of range for JS Date: ${value.nanos} nanos`);
+    }
+    throw new Error(`Expected DuckDBTimestampTZNanosecondsValue`);
+}
 function objectFromIntervalValue(value) {
     if (value instanceof values_1.DuckDBIntervalValue) {
         return {
@@ -188,6 +227,24 @@ function objectFromStructValue(value, type, converter) {
     }
     throw new Error(`Expected DuckDBStructValue and DuckDBStructType`);
 }
+function arrayFromTupleValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBTupleValue &&
+        type instanceof DuckDBType_1.DuckDBStructType &&
+        type.isTuple) {
+        return value.items.map((item, i) => converter(item, type.entryTypes[i], converter));
+    }
+    throw new Error(`Expected DuckDBTupleValue and tuple DuckDBStructType`);
+}
+/**
+ * Converts a STRUCT value: a tuple (see `DuckDBStructType.isTuple`) to an
+ * array of its items, and a named struct to an object keyed by entry name.
+ */
+function objectOrArrayFromStructValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBTupleValue) {
+        return arrayFromTupleValue(value, type, converter);
+    }
+    return objectFromStructValue(value, type, converter);
+}
 function objectArrayFromMapValue(value, type, converter) {
     if (value instanceof values_1.DuckDBMapValue && type instanceof DuckDBType_1.DuckDBMapType) {
         return value.entries.map((entry) => ({
@@ -212,3 +269,73 @@ function objectFromUnionValue(value, type, converter) {
     }
     throw new Error(`Expected DuckDBUnionValue and DuckDBUnionType`);
 }
+/**
+ * Converter for VARIANT values: unwraps the `DuckDBVariantValue` wrapper
+ * and recursively walks the inner value, re-dispatching each scalar leaf
+ * through the supplied converter.
+ *
+ * A walker is needed (rather than just dispatching through the converter)
+ * because VARIANT containers are *heterogeneous* — items in a list or
+ * fields in a struct can have different types — while
+ * `arrayFromListValue` / `objectFromStructValue` / `objectArrayFromMapValue`
+ * assume a homogeneous element type pulled from the enclosing
+ * `DuckDBListType` / `DuckDBStructType` / `DuckDBMapType`. The walker
+ * emits the same output shape those converters do, and prefers the
+ * `DuckDBVariantValue.type` recorded by the decoder over `typeForValue`
+ * inference whenever a wrapper is encountered.
+ */
+function fromVariantValue(value, _type, converter) {
+    if (!(value instanceof values_1.DuckDBVariantValue)) {
+        throw new Error(`Expected DuckDBVariantValue`);
+    }
+    return convertVariantInner(value.value, converter, value.type);
+}
+function convertVariantInner(value, converter, typeHint) {
+    if (value === null) {
+        return null;
+    }
+    if (value instanceof values_1.DuckDBVariantValue) {
+        // Variant-of-variant (or a wrapped child inside a LIST(VARIANT)).
+        // Prefer the wrapper's exact type as the hint for further walking.
+        return convertVariantInner(value.value, converter, value.type ?? typeHint);
+    }
+    if (value instanceof values_1.DuckDBListValue || value instanceof values_1.DuckDBArrayValue) {
+        return value.items.map((item) => convertVariantInner(item, converter));
+    }
+    if (value instanceof values_1.DuckDBStructValue) {
+        const result = {};
+        for (const key in value.entries) {
+            result[key] = convertVariantInner(value.entries[key], converter);
+        }
+        return result;
+    }
+    if (value instanceof values_1.DuckDBTupleValue) {
+        return value.items.map((item) => convertVariantInner(item, converter));
+    }
+    if (value instanceof values_1.DuckDBMapValue) {
+        return value.entries.map((entry) => ({
+            key: convertVariantInner(entry.key, converter),
+            value: convertVariantInner(entry.value, converter),
+        }));
+    }
+    if (value instanceof values_1.DuckDBUnionValue) {
+        return {
+            tag: value.tag,
+            value: convertVariantInner(value.value, converter),
+        };
+    }
+    // Scalar (or non-recursable rich value like DECIMAL, BLOB, DATE, etc.):
+    // dispatch through the regular converter. Use `typeHint` (carried in
+    // from a wrapper) for type fidelity when available; fall back to
+    // `typeForValue` otherwise.
+    const inferredType = typeHint ?? (0, typeForValue_1.typeForValue)(value);
+    // `typeForValue` infers BIGINT for any JS integer number outside INT32
+    // range (e.g. a UINT32 VARIANT payload of 4_294_967_295). The BIGINT
+    // converters expect a `bigint`, not a `number`, and would otherwise
+    // throw. Coerce to bigint so the dispatch lands on a compatible reader.
+    if (typeof value === 'number' &&
+        inferredType.typeId === DuckDBTypeId_1.DuckDBTypeId.BIGINT) {
+        return converter(BigInt(value), inferredType, converter);
+    }
+    return converter(value, inferredType, converter);
+}