slatedb-node 0.1.0 → 0.1.1

package/lib/index.d.ts

@@ -0,0 +1,360 @@
+type Binary = Buffer | Uint8Array | string;
+interface NativeReadOptions {
+    durabilityFilter?: "memory" | "remote";
+    dirty?: boolean;
+    cacheBlocks?: boolean;
+}
+interface NativeScanOptions extends NativeReadOptions {
+    readAheadBytes?: number;
+    maxFetchTasks?: number;
+}
+interface NativeWriteOptions {
+    awaitDurable?: boolean;
+}
+interface NativePutOptions {
+    ttlMs?: number;
+    noExpiry?: boolean;
+}
+interface NativeMergeOptions {
+    ttlMs?: number;
+    noExpiry?: boolean;
+}
+interface NativeCheckpointOptions {
+    lifetimeMs?: number;
+    source?: string;
+    name?: string;
+}
+interface NativeGcDirectoryOptions {
+    intervalMs?: number;
+    minAgeMs?: number;
+}
+interface NativeGcOptions {
+    manifest?: NativeGcDirectoryOptions;
+    wal?: NativeGcDirectoryOptions;
+    compacted?: NativeGcDirectoryOptions;
+    compactions?: NativeGcDirectoryOptions;
+}
+interface NativeCompactionSource {
+    sortedRun?: number;
+    sst?: string;
+}
+interface NativeCompactionSpec {
+    sources: NativeCompactionSource[];
+    destination: number;
+}
+interface NativeKeyValue {
+    key: Buffer;
+    value: Buffer;
+}
+interface NativeWriteHandle {
+    seq: number;
+    createTs: number;
+}
+interface NativeCheckpointCreateResult {
+    id: string;
+    manifestId: number;
+}
+interface NativeCheckpoint {
+    id: string;
+    manifestId: number;
+    expireTimeMs: number | null;
+    createTimeMs: number;
+    name?: string;
+}
+interface NativeSlateDBIterator {
+    next(): Promise<NativeKeyValue | null>;
+    seek(key: Buffer): Promise<void>;
+    close(): Promise<void>;
+}
+interface NativeWriteBatch {
+    put(key: Buffer, value: Buffer): void;
+    putWithOptions(key: Buffer, value: Buffer, options?: NativePutOptions): void;
+    delete(key: Buffer): void;
+    merge(key: Buffer, value: Buffer): void;
+    mergeWithOptions(key: Buffer, value: Buffer, options?: NativeMergeOptions): void;
+}
+interface NativeSlateDBSnapshot {
+    get(key: Buffer): Promise<Buffer | null>;
+    getWithOptions(key: Buffer, options?: NativeReadOptions): Promise<Buffer | null>;
+    scan(start: Buffer, end?: Buffer): Promise<NativeSlateDBIterator>;
+    scanWithOptions(start: Buffer, end?: Buffer, options?: NativeScanOptions): Promise<NativeSlateDBIterator>;
+    scanPrefix(prefix: Buffer): Promise<NativeSlateDBIterator>;
+    scanPrefixWithOptions(prefix: Buffer, options?: NativeScanOptions): Promise<NativeSlateDBIterator>;
+    close(): Promise<void>;
+}
+interface NativeSlateDBTransaction {
+    get(key: Buffer): Promise<Buffer | null>;
+    getWithOptions(key: Buffer, options?: NativeReadOptions): Promise<Buffer | null>;
+    scan(start: Buffer, end?: Buffer): Promise<NativeSlateDBIterator>;
+    scanWithOptions(start: Buffer, end?: Buffer, options?: NativeScanOptions): Promise<NativeSlateDBIterator>;
+    scanPrefix(prefix: Buffer): Promise<NativeSlateDBIterator>;
+    scanPrefixWithOptions(prefix: Buffer, options?: NativeScanOptions): Promise<NativeSlateDBIterator>;
+    put(key: Buffer, value: Buffer): Promise<void>;
+    putWithOptions(key: Buffer, value: Buffer, options?: NativePutOptions): Promise<void>;
+    delete(key: Buffer): Promise<void>;
+    merge(key: Buffer, value: Buffer): Promise<void>;
+    mergeWithOptions(key: Buffer, value: Buffer, options?: NativeMergeOptions): Promise<void>;
+    markRead(keys: Buffer[]): Promise<void>;
+    unmarkWrite(keys: Buffer[]): Promise<void>;
+    commit(writeOptions?: NativeWriteOptions): Promise<NativeWriteHandle | null>;
+    rollback(): Promise<void>;
+    close(): Promise<void>;
+}
+interface NativeSlateDBReader {
+    get(key: Buffer): Promise<Buffer | null>;
+    getWithOptions(key: Buffer, options?: NativeReadOptions): Promise<Buffer | null>;
+    scan(start: Buffer, end?: Buffer): Promise<NativeSlateDBIterator>;
+    scanWithOptions(start: Buffer, end?: Buffer, options?: NativeScanOptions): Promise<NativeSlateDBIterator>;
+    scanPrefix(prefix: Buffer): Promise<NativeSlateDBIterator>;
+    scanPrefixWithOptions(prefix: Buffer, options?: NativeScanOptions): Promise<NativeSlateDBIterator>;
+    close(): Promise<void>;
+}
+interface NativeSlateDBAdmin {
+    readManifest(id?: number): Promise<string | null>;
+    listManifests(start?: number, end?: number): Promise<string>;
+    readCompactions(id?: number): Promise<string | null>;
+    listCompactions(start?: number, end?: number): Promise<string>;
+    readCompaction(id: string, compactionsId?: number): Promise<string | null>;
+    submitCompaction(spec: NativeCompactionSpec): Promise<string>;
+    createCheckpoint(options?: NativeCheckpointOptions): Promise<NativeCheckpointCreateResult>;
+    listCheckpoints(name?: string): Promise<NativeCheckpoint[]>;
+    refreshCheckpoint(id: string, lifetimeMs?: number): Promise<void>;
+    deleteCheckpoint(id: string): Promise<void>;
+    getTimestampForSequence(seq: number, roundUp?: boolean): Promise<number | null>;
+    getSequenceForTimestamp(timestampMs: number, roundUp?: boolean): Promise<number | null>;
+    createClone(parentPath: string, parentCheckpoint?: string): Promise<void>;
+    runGcOnce(options?: NativeGcOptions): Promise<void>;
+    runGc(options?: NativeGcOptions): Promise<void>;
+}
+interface NativeSlateDB {
+    get(key: Buffer): Promise<Buffer | null>;
+    getWithOptions(key: Buffer, options?: NativeReadOptions): Promise<Buffer | null>;
+    put(key: Buffer, value: Buffer): Promise<NativeWriteHandle>;
+    putWithOptions(key: Buffer, value: Buffer, putOptions?: NativePutOptions, writeOptions?: NativeWriteOptions): Promise<NativeWriteHandle>;
+    delete(key: Buffer): Promise<NativeWriteHandle>;
+    deleteWithOptions(key: Buffer, writeOptions?: NativeWriteOptions): Promise<NativeWriteHandle>;
+    merge(key: Buffer, value: Buffer): Promise<NativeWriteHandle>;
+    mergeWithOptions(key: Buffer, value: Buffer, mergeOptions?: NativeMergeOptions, writeOptions?: NativeWriteOptions): Promise<NativeWriteHandle>;
+    write(batch: NativeWriteBatch): Promise<NativeWriteHandle>;
+    writeWithOptions(batch: NativeWriteBatch, writeOptions?: NativeWriteOptions): Promise<NativeWriteHandle>;
+    scan(start: Buffer, end?: Buffer): Promise<NativeSlateDBIterator>;
+    scanWithOptions(start: Buffer, end?: Buffer, options?: NativeScanOptions): Promise<NativeSlateDBIterator>;
+    scanPrefix(prefix: Buffer): Promise<NativeSlateDBIterator>;
+    scanPrefixWithOptions(prefix: Buffer, options?: NativeScanOptions): Promise<NativeSlateDBIterator>;
+    snapshot(): Promise<NativeSlateDBSnapshot>;
+    begin(isolation?: string): Promise<NativeSlateDBTransaction>;
+    flush(): Promise<void>;
+    flushWithOptions(flushType?: "wal" | "memtable"): Promise<void>;
+    metrics(): Promise<Record<string, number>>;
+    createCheckpoint(scope?: "all" | "durable", options?: NativeCheckpointOptions): Promise<NativeCheckpointCreateResult>;
+    status(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class SlateDBError extends Error {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export declare class TransactionError extends SlateDBError {
+}
+export declare class ClosedError extends SlateDBError {
+}
+export declare class UnavailableError extends SlateDBError {
+}
+export declare class InvalidError extends SlateDBError {
+}
+export declare class DataError extends SlateDBError {
+}
+export declare class InternalError extends SlateDBError {
+}
+export interface ReadOptions {
+    durabilityFilter?: "memory" | "remote";
+    dirty?: boolean;
+    cacheBlocks?: boolean;
+}
+export interface ScanOptions extends ReadOptions {
+    readAheadBytes?: number;
+    maxFetchTasks?: number;
+}
+export interface WriteOptions {
+    awaitDurable?: boolean;
+}
+export interface PutOptions {
+    ttlMs?: number;
+    noExpiry?: boolean;
+}
+export interface MergeOptions {
+    ttlMs?: number;
+    noExpiry?: boolean;
+}
+export interface CheckpointOptions {
+    lifetimeMs?: number;
+    source?: string;
+    name?: string;
+}
+export interface GcDirectoryOptions {
+    intervalMs?: number;
+    minAgeMs?: number;
+}
+export interface GcOptions {
+    manifest?: GcDirectoryOptions;
+    wal?: GcDirectoryOptions;
+    compacted?: GcDirectoryOptions;
+    compactions?: GcDirectoryOptions;
+}
+export interface CompactionSource {
+    sortedRun?: number;
+    sst?: string;
+}
+export interface CompactionSpec {
+    sources: CompactionSource[];
+    destination: number;
+}
+export interface WriteHandle {
+    seq: number;
+    createTs: number;
+}
+export interface CheckpointCreateResult {
+    id: string;
+    manifestId: number;
+}
+export interface Checkpoint {
+    id: string;
+    manifestId: number;
+    expireTimeMs: number | null;
+    createTimeMs: number;
+    name?: string;
+}
+export interface SlateDBOpenOptions {
+    path: string;
+    url?: string;
+    envFile?: string;
+    settingsPath?: string;
+    settings?: Record<string, unknown>;
+}
+export interface SlateDBReaderOpenOptions {
+    path: string;
+    url?: string;
+    envFile?: string;
+    checkpointId?: string;
+    manifestPollIntervalMs?: number;
+    checkpointLifetimeMs?: number;
+    maxMemtableBytes?: number;
+    skipWalReplay?: boolean;
+    options?: Record<string, unknown>;
+}
+export interface SlateDBAdminOpenOptions {
+    path: string;
+    url?: string;
+    envFile?: string;
+    walUrl?: string;
+}
+export declare class SlateDBIterator implements AsyncIterable<[Buffer, Buffer]> {
+    private readonly native;
+    constructor(nativeIterator: NativeSlateDBIterator);
+    next(): Promise<[Buffer, Buffer] | null>;
+    seek(key: Binary): Promise<void>;
+    close(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterator<[Buffer, Buffer]>;
+}
+export declare class WriteBatch {
+    private readonly native;
+    constructor();
+    put(key: Binary, value: Binary): void;
+    putWithOptions(key: Binary, value: Binary, options?: PutOptions): void;
+    delete(key: Binary): void;
+    merge(key: Binary, value: Binary): void;
+    mergeWithOptions(key: Binary, value: Binary, options?: MergeOptions): void;
+    getNative(): NativeWriteBatch;
+}
+export declare class SlateDBSnapshot {
+    private readonly native;
+    constructor(nativeSnapshot: NativeSlateDBSnapshot);
+    get(key: Binary): Promise<Buffer | null>;
+    getWithOptions(key: Binary, options?: ReadOptions): Promise<Buffer | null>;
+    scan(start: Binary, end?: Binary): Promise<SlateDBIterator>;
+    scanWithOptions(start: Binary, end?: Binary, options?: ScanOptions): Promise<SlateDBIterator>;
+    scanPrefix(prefix: Binary): Promise<SlateDBIterator>;
+    scanPrefixWithOptions(prefix: Binary, options?: ScanOptions): Promise<SlateDBIterator>;
+    close(): Promise<void>;
+}
+export declare class SlateDBTransaction {
+    private readonly native;
+    constructor(nativeTransaction: NativeSlateDBTransaction);
+    get(key: Binary): Promise<Buffer | null>;
+    getWithOptions(key: Binary, options?: ReadOptions): Promise<Buffer | null>;
+    scan(start: Binary, end?: Binary): Promise<SlateDBIterator>;
+    scanWithOptions(start: Binary, end?: Binary, options?: ScanOptions): Promise<SlateDBIterator>;
+    scanPrefix(prefix: Binary): Promise<SlateDBIterator>;
+    scanPrefixWithOptions(prefix: Binary, options?: ScanOptions): Promise<SlateDBIterator>;
+    put(key: Binary, value: Binary): Promise<void>;
+    putWithOptions(key: Binary, value: Binary, options?: PutOptions): Promise<void>;
+    delete(key: Binary): Promise<void>;
+    merge(key: Binary, value: Binary): Promise<void>;
+    mergeWithOptions(key: Binary, value: Binary, options?: MergeOptions): Promise<void>;
+    markRead(keys: Binary[]): Promise<void>;
+    unmarkWrite(keys: Binary[]): Promise<void>;
+    commit(writeOptions?: WriteOptions): Promise<WriteHandle | null>;
+    rollback(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class SlateDBReader {
+    private readonly native;
+    constructor(nativeReader: NativeSlateDBReader);
+    get(key: Binary): Promise<Buffer | null>;
+    getWithOptions(key: Binary, options?: ReadOptions): Promise<Buffer | null>;
+    scan(start: Binary, end?: Binary): Promise<SlateDBIterator>;
+    scanWithOptions(start: Binary, end?: Binary, options?: ScanOptions): Promise<SlateDBIterator>;
+    scanPrefix(prefix: Binary): Promise<SlateDBIterator>;
+    scanPrefixWithOptions(prefix: Binary, options?: ScanOptions): Promise<SlateDBIterator>;
+    close(): Promise<void>;
+}
+export declare class SlateDBAdmin {
+    private readonly native;
+    constructor(nativeAdmin: NativeSlateDBAdmin);
+    readManifest(id?: number): Promise<string | null>;
+    listManifests(start?: number, end?: number): Promise<string>;
+    readCompactions(id?: number): Promise<string | null>;
+    listCompactions(start?: number, end?: number): Promise<string>;
+    readCompaction(id: string, compactionsId?: number): Promise<string | null>;
+    submitCompaction(spec: CompactionSpec): Promise<string>;
+    createCheckpoint(options?: CheckpointOptions): Promise<CheckpointCreateResult>;
+    listCheckpoints(name?: string): Promise<Checkpoint[]>;
+    refreshCheckpoint(id: string, lifetimeMs?: number): Promise<void>;
+    deleteCheckpoint(id: string): Promise<void>;
+    getTimestampForSequence(seq: number, roundUp?: boolean): Promise<number | null>;
+    getSequenceForTimestamp(timestampMs: number, roundUp?: boolean): Promise<number | null>;
+    createClone(parentPath: string, parentCheckpoint?: string): Promise<void>;
+    runGcOnce(options?: GcOptions): Promise<void>;
+    runGc(options?: GcOptions): Promise<void>;
+}
+export declare class SlateDB {
+    private readonly native;
+    constructor(nativeDb: NativeSlateDB);
+    static open(options: SlateDBOpenOptions): Promise<SlateDB>;
+    get(key: Binary): Promise<Buffer | null>;
+    getWithOptions(key: Binary, options?: ReadOptions): Promise<Buffer | null>;
+    put(key: Binary, value: Binary): Promise<WriteHandle>;
+    putWithOptions(key: Binary, value: Binary, putOptions?: PutOptions, writeOptions?: WriteOptions): Promise<WriteHandle>;
+    delete(key: Binary): Promise<WriteHandle>;
+    deleteWithOptions(key: Binary, writeOptions?: WriteOptions): Promise<WriteHandle>;
+    merge(key: Binary, value: Binary): Promise<WriteHandle>;
+    mergeWithOptions(key: Binary, value: Binary, mergeOptions?: MergeOptions, writeOptions?: WriteOptions): Promise<WriteHandle>;
+    write(batch: WriteBatch): Promise<WriteHandle>;
+    writeWithOptions(batch: WriteBatch, writeOptions?: WriteOptions): Promise<WriteHandle>;
+    scan(start: Binary, end?: Binary): Promise<SlateDBIterator>;
+    scanWithOptions(start: Binary, end?: Binary, options?: ScanOptions): Promise<SlateDBIterator>;
+    scanPrefix(prefix: Binary): Promise<SlateDBIterator>;
+    scanPrefixWithOptions(prefix: Binary, options?: ScanOptions): Promise<SlateDBIterator>;
+    snapshot(): Promise<SlateDBSnapshot>;
+    begin(isolation?: "si" | "snapshot" | "ssi" | "serializable" | "serializable_snapshot"): Promise<SlateDBTransaction>;
+    flush(): Promise<void>;
+    flushWithOptions(flushType?: "wal" | "memtable"): Promise<void>;
+    metrics(): Promise<Record<string, number>>;
+    createCheckpoint(scope?: "all" | "durable", options?: CheckpointOptions): Promise<CheckpointCreateResult>;
+    status(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function open(options: SlateDBOpenOptions): Promise<SlateDB>;
+export declare function openReader(options: SlateDBReaderOpenOptions): Promise<SlateDBReader>;
+export declare function openAdmin(options: SlateDBAdminOpenOptions): Promise<SlateDBAdmin>;
+export {};

package/lib/index.js

@@ -0,0 +1,458 @@
+/* eslint-disable func-style, @typescript-eslint/consistent-type-definitions */
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const native = require("../native.cjs");
+function toBuffer(value) {
+    if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        return Buffer.from(value);
+    }
+    return Buffer.from(value);
+}
+function mapError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    for (const [prefix, ErrorClass] of errorClassMap) {
+        if (message.startsWith(prefix)) {
+            return new ErrorClass(message.slice(prefix.length).trim(), error);
+        }
+    }
+    if (error instanceof Error) {
+        return error;
+    }
+    return new SlateDBError(message, error);
+}
+async function call(fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        throw mapError(error);
+    }
+}
+function mapWriteHandle(handle) {
+    return {
+        seq: handle.seq,
+        createTs: handle.createTs,
+    };
+}
+function mapCheckpointResult(result) {
+    return {
+        id: result.id,
+        manifestId: result.manifestId,
+    };
+}
+function mapCheckpoint(checkpoint) {
+    return {
+        id: checkpoint.id,
+        manifestId: checkpoint.manifestId,
+        expireTimeMs: checkpoint.expireTimeMs,
+        createTimeMs: checkpoint.createTimeMs,
+        name: checkpoint.name,
+    };
+}
+export class SlateDBError extends Error {
+    constructor(message, cause) {
+        super(message);
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = new.target.name;
+        this.cause = cause;
+    }
+}
+export class TransactionError extends SlateDBError {
+}
+export class ClosedError extends SlateDBError {
+}
+export class UnavailableError extends SlateDBError {
+}
+export class InvalidError extends SlateDBError {
+}
+export class DataError extends SlateDBError {
+}
+export class InternalError extends SlateDBError {
+}
+const errorClassMap = [
+    ["TransactionError:", TransactionError],
+    ["ClosedError:", ClosedError],
+    ["UnavailableError:", UnavailableError],
+    ["InvalidError:", InvalidError],
+    ["DataError:", DataError],
+    ["InternalError:", InternalError],
+];
+export class SlateDBIterator {
+    constructor(nativeIterator) {
+        Object.defineProperty(this, "native", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.native = nativeIterator;
+    }
+    async next() {
+        const kv = await call(() => this.native.next());
+        if (kv == null) {
+            return null;
+        }
+        return [kv.key, kv.value];
+    }
+    async seek(key) {
+        await call(() => this.native.seek(toBuffer(key)));
+    }
+    async close() {
+        await call(() => this.native.close());
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = await this.next();
+                if (value == null) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+                return {
+                    done: false,
+                    value,
+                };
+            },
+        };
+    }
+}
+export class WriteBatch {
+    constructor() {
+        Object.defineProperty(this, "native", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.native = new native.NativeWriteBatch();
+    }
+    put(key, value) {
+        this.native.put(toBuffer(key), toBuffer(value));
+    }
+    putWithOptions(key, value, options) {
+        this.native.putWithOptions(toBuffer(key), toBuffer(value), options);
+    }
+    delete(key) {
+        this.native.delete(toBuffer(key));
+    }
+    merge(key, value) {
+        this.native.merge(toBuffer(key), toBuffer(value));
+    }
+    mergeWithOptions(key, value, options) {
+        this.native.mergeWithOptions(toBuffer(key), toBuffer(value), options);
+    }
+    getNative() {
+        return this.native;
+    }
+}
+export class SlateDBSnapshot {
+    constructor(nativeSnapshot) {
+        Object.defineProperty(this, "native", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.native = nativeSnapshot;
+    }
+    async get(key) {
+        return call(() => this.native.get(toBuffer(key)));
+    }
+    async getWithOptions(key, options) {
+        return call(() => this.native.getWithOptions(toBuffer(key), options));
+    }
+    async scan(start, end) {
+        const iterator = await call(() => this.native.scan(toBuffer(start), end == null ? undefined : toBuffer(end)));
+        return new SlateDBIterator(iterator);
+    }
+    async scanWithOptions(start, end, options) {
+        const iterator = await call(() => this.native.scanWithOptions(toBuffer(start), end == null ? undefined : toBuffer(end), options));
+        return new SlateDBIterator(iterator);
+    }
+    async scanPrefix(prefix) {
+        const iterator = await call(() => this.native.scanPrefix(toBuffer(prefix)));
+        return new SlateDBIterator(iterator);
+    }
+    async scanPrefixWithOptions(prefix, options) {
+        const iterator = await call(() => this.native.scanPrefixWithOptions(toBuffer(prefix), options));
+        return new SlateDBIterator(iterator);
+    }
+    async close() {
+        await call(() => this.native.close());
+    }
+}
+export class SlateDBTransaction {
+    constructor(nativeTransaction) {
+        Object.defineProperty(this, "native", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.native = nativeTransaction;
+    }
+    async get(key) {
+        return call(() => this.native.get(toBuffer(key)));
+    }
+    async getWithOptions(key, options) {
+        return call(() => this.native.getWithOptions(toBuffer(key), options));
+    }
+    async scan(start, end) {
+        const iterator = await call(() => this.native.scan(toBuffer(start), end == null ? undefined : toBuffer(end)));
+        return new SlateDBIterator(iterator);
+    }
+    async scanWithOptions(start, end, options) {
+        const iterator = await call(() => this.native.scanWithOptions(toBuffer(start), end == null ? undefined : toBuffer(end), options));
+        return new SlateDBIterator(iterator);
+    }
+    async scanPrefix(prefix) {
+        const iterator = await call(() => this.native.scanPrefix(toBuffer(prefix)));
+        return new SlateDBIterator(iterator);
+    }
+    async scanPrefixWithOptions(prefix, options) {
+        const iterator = await call(() => this.native.scanPrefixWithOptions(toBuffer(prefix), options));
+        return new SlateDBIterator(iterator);
+    }
+    async put(key, value) {
+        await call(() => this.native.put(toBuffer(key), toBuffer(value)));
+    }
+    async putWithOptions(key, value, options) {
+        await call(() => this.native.putWithOptions(toBuffer(key), toBuffer(value), options));
+    }
+    async delete(key) {
+        await call(() => this.native.delete(toBuffer(key)));
+    }
+    async merge(key, value) {
+        await call(() => this.native.merge(toBuffer(key), toBuffer(value)));
+    }
+    async mergeWithOptions(key, value, options) {
+        await call(() => this.native.mergeWithOptions(toBuffer(key), toBuffer(value), options));
+    }
+    async markRead(keys) {
+        await call(() => this.native.markRead(keys.map(toBuffer)));
+    }
+    async unmarkWrite(keys) {
+        await call(() => this.native.unmarkWrite(keys.map(toBuffer)));
+    }
+    async commit(writeOptions) {
+        const handle = await call(() => this.native.commit(writeOptions));
+        return handle == null ? null : mapWriteHandle(handle);
+    }
+    async rollback() {
+        await call(() => this.native.rollback());
+    }
+    async close() {
+        await call(() => this.native.close());
+    }
+}
+export class SlateDBReader {
+    constructor(nativeReader) {
+        Object.defineProperty(this, "native", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.native = nativeReader;
+    }
+    async get(key) {
+        return call(() => this.native.get(toBuffer(key)));
+    }
+    async getWithOptions(key, options) {
+        return call(() => this.native.getWithOptions(toBuffer(key), options));
+    }
+    async scan(start, end) {
+        const iterator = await call(() => this.native.scan(toBuffer(start), end == null ? undefined : toBuffer(end)));
+        return new SlateDBIterator(iterator);
+    }
+    async scanWithOptions(start, end, options) {
+        const iterator = await call(() => this.native.scanWithOptions(toBuffer(start), end == null ? undefined : toBuffer(end), options));
+        return new SlateDBIterator(iterator);
+    }
+    async scanPrefix(prefix) {
+        const iterator = await call(() => this.native.scanPrefix(toBuffer(prefix)));
+        return new SlateDBIterator(iterator);
+    }
+    async scanPrefixWithOptions(prefix, options) {
+        const iterator = await call(() => this.native.scanPrefixWithOptions(toBuffer(prefix), options));
+        return new SlateDBIterator(iterator);
+    }
+    async close() {
+        await call(() => this.native.close());
+    }
+}
+export class SlateDBAdmin {
+    constructor(nativeAdmin) {
+        Object.defineProperty(this, "native", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.native = nativeAdmin;
+    }
+    async readManifest(id) {
+        return call(() => this.native.readManifest(id));
+    }
+    async listManifests(start, end) {
+        return call(() => this.native.listManifests(start, end));
+    }
+    async readCompactions(id) {
+        return call(() => this.native.readCompactions(id));
+    }
+    async listCompactions(start, end) {
+        return call(() => this.native.listCompactions(start, end));
+    }
+    async readCompaction(id, compactionsId) {
+        return call(() => this.native.readCompaction(id, compactionsId));
+    }
+    async submitCompaction(spec) {
+        return call(() => this.native.submitCompaction(spec));
+    }
+    async createCheckpoint(options) {
+        const result = await call(() => this.native.createCheckpoint(options));
+        return mapCheckpointResult(result);
+    }
+    async listCheckpoints(name) {
+        const checkpoints = await call(() => this.native.listCheckpoints(name));
+        return checkpoints.map(mapCheckpoint);
+    }
+    async refreshCheckpoint(id, lifetimeMs) {
+        await call(() => this.native.refreshCheckpoint(id, lifetimeMs));
+    }
+    async deleteCheckpoint(id) {
+        await call(() => this.native.deleteCheckpoint(id));
+    }
+    async getTimestampForSequence(seq, roundUp) {
+        return call(() => this.native.getTimestampForSequence(seq, roundUp));
+    }
+    async getSequenceForTimestamp(timestampMs, roundUp) {
+        return call(() => this.native.getSequenceForTimestamp(timestampMs, roundUp));
+    }
+    async createClone(parentPath, parentCheckpoint) {
+        await call(() => this.native.createClone(parentPath, parentCheckpoint));
+    }
+    async runGcOnce(options) {
+        await call(() => this.native.runGcOnce(options));
+    }
+    async runGc(options) {
+        await call(() => this.native.runGc(options));
+    }
+}
+export class SlateDB {
+    constructor(nativeDb) {
+        Object.defineProperty(this, "native", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.native = nativeDb;
+    }
+    static async open(options) {
+        return open(options);
+    }
+    async get(key) {
+        return call(() => this.native.get(toBuffer(key)));
+    }
+    async getWithOptions(key, options) {
+        return call(() => this.native.getWithOptions(toBuffer(key), options));
+    }
+    async put(key, value) {
+        const handle = await call(() => this.native.put(toBuffer(key), toBuffer(value)));
+        return mapWriteHandle(handle);
+    }
+    async putWithOptions(key, value, putOptions, writeOptions) {
+        const handle = await call(() => this.native.putWithOptions(toBuffer(key), toBuffer(value), putOptions, writeOptions));
+        return mapWriteHandle(handle);
+    }
+    async delete(key) {
+        const handle = await call(() => this.native.delete(toBuffer(key)));
+        return mapWriteHandle(handle);
+    }
+    async deleteWithOptions(key, writeOptions) {
+        const handle = await call(() => this.native.deleteWithOptions(toBuffer(key), writeOptions));
+        return mapWriteHandle(handle);
+    }
+    async merge(key, value) {
+        const handle = await call(() => this.native.merge(toBuffer(key), toBuffer(value)));
+        return mapWriteHandle(handle);
+    }
+    async mergeWithOptions(key, value, mergeOptions, writeOptions) {
+        const handle = await call(() => this.native.mergeWithOptions(toBuffer(key), toBuffer(value), mergeOptions, writeOptions));
+        return mapWriteHandle(handle);
+    }
+    async write(batch) {
+        const handle = await call(() => this.native.write(batch.getNative()));
+        return mapWriteHandle(handle);
+    }
+    async writeWithOptions(batch, writeOptions) {
+        const handle = await call(() => this.native.writeWithOptions(batch.getNative(), writeOptions));
+        return mapWriteHandle(handle);
+    }
+    async scan(start, end) {
+        const iterator = await call(() => this.native.scan(toBuffer(start), end == null ? undefined : toBuffer(end)));
+        return new SlateDBIterator(iterator);
+    }
+    async scanWithOptions(start, end, options) {
+        const iterator = await call(() => this.native.scanWithOptions(toBuffer(start), end == null ? undefined : toBuffer(end), options));
+        return new SlateDBIterator(iterator);
+    }
+    async scanPrefix(prefix) {
+        const iterator = await call(() => this.native.scanPrefix(toBuffer(prefix)));
+        return new SlateDBIterator(iterator);
+    }
+    async scanPrefixWithOptions(prefix, options) {
+        const iterator = await call(() => this.native.scanPrefixWithOptions(toBuffer(prefix), options));
+        return new SlateDBIterator(iterator);
+    }
+    async snapshot() {
+        const snapshot = await call(() => this.native.snapshot());
+        return new SlateDBSnapshot(snapshot);
+    }
+    async begin(isolation) {
+        const txn = await call(() => this.native.begin(isolation));
+        return new SlateDBTransaction(txn);
+    }
+    async flush() {
+        await call(() => this.native.flush());
+    }
+    async flushWithOptions(flushType) {
+        await call(() => this.native.flushWithOptions(flushType));
+    }
+    async metrics() {
+        return call(() => this.native.metrics());
+    }
+    async createCheckpoint(scope, options) {
+        const result = await call(() => this.native.createCheckpoint(scope, options));
+        return mapCheckpointResult(result);
+    }
+    async status() {
+        await call(() => this.native.status());
+    }
+    async close() {
+        await call(() => this.native.close());
+    }
+}
+export async function open(options) {
+    const db = await call(() => native.openNative(options));
+    return new SlateDB(db);
+}
+export async function openReader(options) {
+    const reader = await call(() => native.openReaderNative(options));
+    return new SlateDBReader(reader);
+}
+export async function openAdmin(options) {
+    const admin = await call(() => native.openAdminNative(options));
+    return new SlateDBAdmin(admin);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slatedb-node",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Node.js bindings for SlateDB via napi-rs",
   "homepage": "https://github.com/gadget-inc/slatedb-node",
   "bugs": {
@@ -50,9 +50,11 @@
     "test": "pnpm run build:debug && pnpm run build:ts && vitest run"
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
     "@napi-rs/cli": "^3.2.0",
     "@types/node": "^24.5.2",
     "cspell": "^9.6.4",
+    "execa": "^5.1.1",
     "oxfmt": "^0.32.0",
     "oxlint": "^1.49.0",
     "oxlint-tsgolint": "^0.14.1",
@@ -85,13 +87,13 @@
     }
   },
   "optionalDependencies": {
-    "slatedb-node-darwin-x64": "0.1.0",
-    "slatedb-node-darwin-arm64": "0.1.0",
-    "slatedb-node-win32-x64-msvc": "0.1.0",
-    "slatedb-node-win32-arm64-msvc": "0.1.0",
-    "slatedb-node-linux-x64-gnu": "0.1.0",
-    "slatedb-node-linux-x64-musl": "0.1.0",
-    "slatedb-node-linux-arm64-gnu": "0.1.0",
-    "slatedb-node-linux-arm64-musl": "0.1.0"
+    "slatedb-node-darwin-x64": "0.1.1",
+    "slatedb-node-darwin-arm64": "0.1.1",
+    "slatedb-node-win32-x64-msvc": "0.1.1",
+    "slatedb-node-win32-arm64-msvc": "0.1.1",
+    "slatedb-node-linux-x64-gnu": "0.1.1",
+    "slatedb-node-linux-x64-musl": "0.1.1",
+    "slatedb-node-linux-arm64-gnu": "0.1.1",
+    "slatedb-node-linux-arm64-musl": "0.1.1"
   }
 }