@haybarn/node-api 1.5.3-rc2

package/lib/DuckDBTypeId.d.ts

@@ -0,0 +1,42 @@
+export declare enum DuckDBTypeId {
+    INVALID = 0,
+    BOOLEAN = 1,
+    TINYINT = 2,
+    SMALLINT = 3,
+    INTEGER = 4,
+    BIGINT = 5,
+    UTINYINT = 6,
+    USMALLINT = 7,
+    UINTEGER = 8,
+    UBIGINT = 9,
+    FLOAT = 10,
+    DOUBLE = 11,
+    TIMESTAMP = 12,
+    DATE = 13,
+    TIME = 14,
+    INTERVAL = 15,
+    HUGEINT = 16,
+    UHUGEINT = 32,
+    VARCHAR = 17,
+    BLOB = 18,
+    DECIMAL = 19,
+    TIMESTAMP_S = 20,
+    TIMESTAMP_MS = 21,
+    TIMESTAMP_NS = 22,
+    ENUM = 23,
+    LIST = 24,
+    STRUCT = 25,
+    MAP = 26,
+    ARRAY = 33,
+    UUID = 27,
+    UNION = 28,
+    BIT = 29,
+    TIME_TZ = 30,
+    TIMESTAMP_TZ = 31,
+    ANY = 34,
+    BIGNUM = 35,
+    SQLNULL = 36,
+    STRING_LITERAL = 37,
+    INTEGER_LITERAL = 38,
+    TIME_NS = 39
+}

package/lib/DuckDBTypeId.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTypeId = void 0;
+// copy of duckdb_type, with names shortened
+var DuckDBTypeId;
+(function (DuckDBTypeId) {
+    DuckDBTypeId[DuckDBTypeId["INVALID"] = 0] = "INVALID";
+    DuckDBTypeId[DuckDBTypeId["BOOLEAN"] = 1] = "BOOLEAN";
+    DuckDBTypeId[DuckDBTypeId["TINYINT"] = 2] = "TINYINT";
+    DuckDBTypeId[DuckDBTypeId["SMALLINT"] = 3] = "SMALLINT";
+    DuckDBTypeId[DuckDBTypeId["INTEGER"] = 4] = "INTEGER";
+    DuckDBTypeId[DuckDBTypeId["BIGINT"] = 5] = "BIGINT";
+    DuckDBTypeId[DuckDBTypeId["UTINYINT"] = 6] = "UTINYINT";
+    DuckDBTypeId[DuckDBTypeId["USMALLINT"] = 7] = "USMALLINT";
+    DuckDBTypeId[DuckDBTypeId["UINTEGER"] = 8] = "UINTEGER";
+    DuckDBTypeId[DuckDBTypeId["UBIGINT"] = 9] = "UBIGINT";
+    DuckDBTypeId[DuckDBTypeId["FLOAT"] = 10] = "FLOAT";
+    DuckDBTypeId[DuckDBTypeId["DOUBLE"] = 11] = "DOUBLE";
+    DuckDBTypeId[DuckDBTypeId["TIMESTAMP"] = 12] = "TIMESTAMP";
+    DuckDBTypeId[DuckDBTypeId["DATE"] = 13] = "DATE";
+    DuckDBTypeId[DuckDBTypeId["TIME"] = 14] = "TIME";
+    DuckDBTypeId[DuckDBTypeId["INTERVAL"] = 15] = "INTERVAL";
+    DuckDBTypeId[DuckDBTypeId["HUGEINT"] = 16] = "HUGEINT";
+    DuckDBTypeId[DuckDBTypeId["UHUGEINT"] = 32] = "UHUGEINT";
+    DuckDBTypeId[DuckDBTypeId["VARCHAR"] = 17] = "VARCHAR";
+    DuckDBTypeId[DuckDBTypeId["BLOB"] = 18] = "BLOB";
+    DuckDBTypeId[DuckDBTypeId["DECIMAL"] = 19] = "DECIMAL";
+    DuckDBTypeId[DuckDBTypeId["TIMESTAMP_S"] = 20] = "TIMESTAMP_S";
+    DuckDBTypeId[DuckDBTypeId["TIMESTAMP_MS"] = 21] = "TIMESTAMP_MS";
+    DuckDBTypeId[DuckDBTypeId["TIMESTAMP_NS"] = 22] = "TIMESTAMP_NS";
+    DuckDBTypeId[DuckDBTypeId["ENUM"] = 23] = "ENUM";
+    DuckDBTypeId[DuckDBTypeId["LIST"] = 24] = "LIST";
+    DuckDBTypeId[DuckDBTypeId["STRUCT"] = 25] = "STRUCT";
+    DuckDBTypeId[DuckDBTypeId["MAP"] = 26] = "MAP";
+    DuckDBTypeId[DuckDBTypeId["ARRAY"] = 33] = "ARRAY";
+    DuckDBTypeId[DuckDBTypeId["UUID"] = 27] = "UUID";
+    DuckDBTypeId[DuckDBTypeId["UNION"] = 28] = "UNION";
+    DuckDBTypeId[DuckDBTypeId["BIT"] = 29] = "BIT";
+    DuckDBTypeId[DuckDBTypeId["TIME_TZ"] = 30] = "TIME_TZ";
+    DuckDBTypeId[DuckDBTypeId["TIMESTAMP_TZ"] = 31] = "TIMESTAMP_TZ";
+    DuckDBTypeId[DuckDBTypeId["ANY"] = 34] = "ANY";
+    DuckDBTypeId[DuckDBTypeId["BIGNUM"] = 35] = "BIGNUM";
+    DuckDBTypeId[DuckDBTypeId["SQLNULL"] = 36] = "SQLNULL";
+    DuckDBTypeId[DuckDBTypeId["STRING_LITERAL"] = 37] = "STRING_LITERAL";
+    DuckDBTypeId[DuckDBTypeId["INTEGER_LITERAL"] = 38] = "INTEGER_LITERAL";
+    DuckDBTypeId[DuckDBTypeId["TIME_NS"] = 39] = "TIME_NS";
+})(DuckDBTypeId || (exports.DuckDBTypeId = DuckDBTypeId = {}));

package/lib/DuckDBValueConverter.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+export type DuckDBValueConverter<T> = (value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>) => T | null;

package/lib/DuckDBValueConverter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/DuckDBValueConverters.d.ts

@@ -0,0 +1,47 @@
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+import { DuckDBValue } from './values';
+export declare function unsupportedConverter(_: DuckDBValue, type: DuckDBType): null;
+export declare function nullConverter(_: DuckDBValue): null;
+export declare function booleanFromValue(value: DuckDBValue): boolean;
+export declare function numberFromValue(value: DuckDBValue): number;
+export declare function jsonNumberFromValue(value: DuckDBValue): number | string;
+export declare function bigintFromBigIntValue(value: DuckDBValue, type: DuckDBType): bigint;
+export declare function stringFromValue(value: DuckDBValue): string;
+export declare function bytesFromBlobValue(value: DuckDBValue): Uint8Array;
+export declare function bytesFromBitValue(value: DuckDBValue): Uint8Array;
+export declare function dateFromDateValue(value: DuckDBValue): Date;
+export declare function bigintFromTimeValue(value: DuckDBValue): bigint;
+export declare function dateFromTimestampValue(value: DuckDBValue): Date;
+export declare function dateFromTimestampSecondsValue(value: DuckDBValue): Date;
+export declare function dateFromTimestampMillisecondsValue(value: DuckDBValue): Date;
+export declare function dateFromTimestampNanosecondsValue(value: DuckDBValue): Date;
+export declare function objectFromTimeTZValue(value: DuckDBValue): {
+    micros: bigint;
+    offset: number;
+};
+export declare function dateFromTimestampTZValue(value: DuckDBValue): Date;
+export declare function objectFromIntervalValue(value: DuckDBValue): {
+    months: number;
+    days: number;
+    micros: bigint;
+};
+export declare function jsonObjectFromIntervalValue(value: DuckDBValue): {
+    months: number;
+    days: number;
+    micros: string;
+};
+export declare function doubleFromDecimalValue(value: DuckDBValue): number;
+export declare function arrayFromListValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): (T | null)[];
+export declare function objectFromStructValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): {
+    [key: string]: T | null;
+};
+export declare function objectArrayFromMapValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): {
+    key: T | null;
+    value: T | null;
+}[];
+export declare function arrayFromArrayValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): (T | null)[];
+export declare function objectFromUnionValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): {
+    tag: string;
+    value: T | null;
+};

package/lib/DuckDBValueConverters.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsupportedConverter = unsupportedConverter;
+exports.nullConverter = nullConverter;
+exports.booleanFromValue = booleanFromValue;
+exports.numberFromValue = numberFromValue;
+exports.jsonNumberFromValue = jsonNumberFromValue;
+exports.bigintFromBigIntValue = bigintFromBigIntValue;
+exports.stringFromValue = stringFromValue;
+exports.bytesFromBlobValue = bytesFromBlobValue;
+exports.bytesFromBitValue = bytesFromBitValue;
+exports.dateFromDateValue = dateFromDateValue;
+exports.bigintFromTimeValue = bigintFromTimeValue;
+exports.dateFromTimestampValue = dateFromTimestampValue;
+exports.dateFromTimestampSecondsValue = dateFromTimestampSecondsValue;
+exports.dateFromTimestampMillisecondsValue = dateFromTimestampMillisecondsValue;
+exports.dateFromTimestampNanosecondsValue = dateFromTimestampNanosecondsValue;
+exports.objectFromTimeTZValue = objectFromTimeTZValue;
+exports.dateFromTimestampTZValue = dateFromTimestampTZValue;
+exports.objectFromIntervalValue = objectFromIntervalValue;
+exports.jsonObjectFromIntervalValue = jsonObjectFromIntervalValue;
+exports.doubleFromDecimalValue = doubleFromDecimalValue;
+exports.arrayFromListValue = arrayFromListValue;
+exports.objectFromStructValue = objectFromStructValue;
+exports.objectArrayFromMapValue = objectArrayFromMapValue;
+exports.arrayFromArrayValue = arrayFromArrayValue;
+exports.objectFromUnionValue = objectFromUnionValue;
+const DuckDBType_1 = require("./DuckDBType");
+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;
+const MILLS_PER_DAY = 24 * 60 * 60 * 1000;
+function unsupportedConverter(_, type) {
+    throw new Error(`Unsupported type: ${type}`);
+}
+function nullConverter(_) {
+    return null;
+}
+function booleanFromValue(value) {
+    return Boolean(value);
+}
+function numberFromValue(value) {
+    return Number(value);
+}
+function jsonNumberFromValue(value) {
+    if (Number.isFinite(value)) {
+        return Number(value);
+    }
+    return String(value);
+}
+function bigintFromBigIntValue(value, type) {
+    if (typeof value === 'bigint') {
+        return value;
+    }
+    throw new Error(`Expected bigint value for type ${type}`);
+}
+function stringFromValue(value) {
+    return String(value);
+}
+function bytesFromBlobValue(value) {
+    if (value instanceof values_1.DuckDBBlobValue) {
+        return value.bytes;
+    }
+    throw new Error(`Expected DuckDBBlobValue`);
+}
+function bytesFromBitValue(value) {
+    if (value instanceof values_1.DuckDBBitValue) {
+        return value.data;
+    }
+    throw new Error(`Expected DuckDBBitValue`);
+}
+function dateFromDateValue(value) {
+    if (value instanceof values_1.DuckDBDateValue) {
+        if (MIN_DATE_DAYS <= value.days && value.days <= MAX_DATE_DAYS) {
+            return new Date(value.days * MILLS_PER_DAY);
+        }
+        throw new Error(`DATE value out of range for JS Date: ${value.days} days`);
+    }
+    throw new Error(`Expected DuckDBDateValue`);
+}
+function bigintFromTimeValue(value) {
+    if (value instanceof values_1.DuckDBTimeValue) {
+        return value.micros;
+    }
+    throw new Error(`Expected DuckDBTimeValue`);
+}
+function dateFromTimestampValue(value) {
+    if (value instanceof values_1.DuckDBTimestampValue) {
+        const millis = value.micros / 1000n;
+        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMP value out of range for JS Date: ${value.micros} micros`);
+    }
+    throw new Error(`Expected DuckDBTimestampValue`);
+}
+function dateFromTimestampSecondsValue(value) {
+    if (value instanceof values_1.DuckDBTimestampSecondsValue) {
+        const millis = value.seconds * 1000n;
+        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMP_S value out of range for JS Date: ${value.seconds} seconds`);
+    }
+    throw new Error(`Expected DuckDBTimestampSecondsValue`);
+}
+function dateFromTimestampMillisecondsValue(value) {
+    if (value instanceof values_1.DuckDBTimestampMillisecondsValue) {
+        const millis = value.millis;
+        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMP_MS value out of range for JS Date: ${value.millis} millis`);
+    }
+    throw new Error(`Expected DuckDBTimestampMillisecondsValue`);
+}
+function dateFromTimestampNanosecondsValue(value) {
+    if (value instanceof values_1.DuckDBTimestampNanosecondsValue) {
+        const millis = value.nanos / 1000000n;
+        if (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`);
+    }
+    throw new Error(`Expected DuckDBTimestampNanosecondsValue`);
+}
+function objectFromTimeTZValue(value) {
+    if (value instanceof values_1.DuckDBTimeTZValue) {
+        return {
+            micros: value.micros,
+            offset: value.offset,
+        };
+    }
+    throw new Error(`Expected DuckDBTimeTZValue`);
+}
+function dateFromTimestampTZValue(value) {
+    if (value instanceof values_1.DuckDBTimestampTZValue) {
+        const millis = value.micros / 1000n;
+        if (MIN_DATE_MILLIS <= millis && millis <= MAX_DATE_MILLIS) {
+            return new Date(Number(millis));
+        }
+        throw new Error(`TIMESTAMPTZ value out of range for JS Date: ${value.micros} micros`);
+    }
+    throw new Error(`Expected DuckDBTimestampTZValue`);
+}
+function objectFromIntervalValue(value) {
+    if (value instanceof values_1.DuckDBIntervalValue) {
+        return {
+            months: value.months,
+            days: value.days,
+            micros: value.micros,
+        };
+    }
+    throw new Error(`Expected DuckDBIntervalValue`);
+}
+function jsonObjectFromIntervalValue(value) {
+    if (value instanceof values_1.DuckDBIntervalValue) {
+        return {
+            months: value.months,
+            days: value.days,
+            micros: String(value.micros),
+        };
+    }
+    throw new Error(`Expected DuckDBIntervalValue`);
+}
+function doubleFromDecimalValue(value) {
+    if (value instanceof values_1.DuckDBDecimalValue) {
+        return value.toDouble();
+    }
+    throw new Error(`Expected DuckDBDecimalValue`);
+}
+function arrayFromListValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBListValue && type instanceof DuckDBType_1.DuckDBListType) {
+        return value.items.map((v) => converter(v, type.valueType, converter));
+    }
+    throw new Error(`Expected DuckDBListValue and DuckDBListType`);
+}
+function objectFromStructValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBStructValue && type instanceof DuckDBType_1.DuckDBStructType) {
+        const result = {};
+        for (const key in value.entries) {
+            result[key] = converter(value.entries[key], type.typeForEntry(key), converter);
+        }
+        return result;
+    }
+    throw new Error(`Expected DuckDBStructValue and DuckDBStructType`);
+}
+function objectArrayFromMapValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBMapValue && type instanceof DuckDBType_1.DuckDBMapType) {
+        return value.entries.map((entry) => ({
+            key: converter(entry.key, type.keyType, converter),
+            value: converter(entry.value, type.valueType, converter),
+        }));
+    }
+    throw new Error(`Expected DuckDBMapValue and DuckDBMapType`);
+}
+function arrayFromArrayValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBArrayValue && type instanceof DuckDBType_1.DuckDBArrayType) {
+        return value.items.map((v) => converter(v, type.valueType, converter));
+    }
+    throw new Error(`Expected DuckDBArrayValue and DuckDBArrayType`);
+}
+function objectFromUnionValue(value, type, converter) {
+    if (value instanceof values_1.DuckDBUnionValue && type instanceof DuckDBType_1.DuckDBUnionType) {
+        return {
+            tag: value.tag,
+            value: converter(value.value, type.memberTypeForTag(value.tag), converter),
+        };
+    }
+    throw new Error(`Expected DuckDBUnionValue and DuckDBUnionType`);
+}