xitdb 0.12.0 → 0.14.0

package/dist/write-cursor.js

@@ -0,0 +1,124 @@
+import { Slot } from './slot.js';
+import { WriteMode, WriteData, } from './database.js';
+import { ReadCursor, KeyValuePairCursor, CursorIterator, } from './read-cursor.js';
+import { CursorNotWriteableException, EndOfStreamException, UnexpectedWriterPositionException, } from './exceptions.js';
+export class WriteKeyValuePairCursor extends KeyValuePairCursor {
+    valueCursor;
+    keyCursor;
+    constructor(valueCursor, keyCursor, hash) {
+        super(valueCursor, keyCursor, hash);
+        this.valueCursor = valueCursor;
+        this.keyCursor = keyCursor;
+    }
+}
+export class WriteCursor extends ReadCursor {
+    constructor(slotPtr, db) {
+        super(slotPtr, db);
+    }
+    writePath(path) {
+        const slotPtr = this.db.readSlotPointer(WriteMode.READ_WRITE, path, 0, this.slotPtr);
+        if (this.db.txStart === null) {
+            this.db.core.sync();
+        }
+        return new WriteCursor(slotPtr, this.db);
+    }
+    write(data) {
+        const cursor = this.writePath([new WriteData(data)]);
+        this.slotPtr = cursor.slotPtr;
+    }
+    writeIfEmpty(data) {
+        if (this.slotPtr.slot.empty()) {
+            this.write(data);
+        }
+    }
+    readKeyValuePair() {
+        const kvPairCursor = super.readKeyValuePair();
+        return new WriteKeyValuePairCursor(new WriteCursor(kvPairCursor.valueCursor.slotPtr, this.db), new WriteCursor(kvPairCursor.keyCursor.slotPtr, this.db), kvPairCursor.hash);
+    }
+    writer() {
+        const writer = this.db.core.writer();
+        const ptrPos = this.db.core.length();
+        this.db.core.seek(ptrPos);
+        writer.writeLong(0);
+        const startPosition = this.db.core.length();
+        return new Writer(this, 0, new Slot(ptrPos, 6 /* Tag.BYTES */), startPosition, 0);
+    }
+    *[Symbol.iterator]() {
+        const iterator = this.iterator();
+        while (iterator.hasNext()) {
+            const next = iterator.next();
+            if (next !== null) {
+                yield next;
+            }
+        }
+    }
+    iterator() {
+        const iterator = new WriteCursorIterator(this);
+        iterator.init();
+        return iterator;
+    }
+}
+export class Writer {
+    parent;
+    size;
+    slot;
+    startPosition;
+    relativePosition;
+    formatTag = null;
+    constructor(parent, size, slot, startPosition, relativePosition) {
+        this.parent = parent;
+        this.size = size;
+        this.slot = slot;
+        this.startPosition = startPosition;
+        this.relativePosition = relativePosition;
+    }
+    write(buffer) {
+        if (this.size < this.relativePosition)
+            throw new EndOfStreamException();
+        this.parent.db.core.seek(this.startPosition + this.relativePosition);
+        const writer = this.parent.db.core.writer();
+        writer.write(buffer);
+        this.relativePosition += buffer.length;
+        if (this.relativePosition > this.size) {
+            this.size = this.relativePosition;
+        }
+    }
+    finish() {
+        const writer = this.parent.db.core.writer();
+        if (this.formatTag !== null) {
+            this.slot = this.slot.withFull(true);
+            const formatTagPos = this.parent.db.core.length();
+            this.parent.db.core.seek(formatTagPos);
+            if (this.startPosition + this.size !== formatTagPos)
+                throw new UnexpectedWriterPositionException();
+            writer.write(this.formatTag);
+        }
+        this.parent.db.core.seek(Number(this.slot.value));
+        writer.writeLong(this.size);
+        if (this.parent.slotPtr.position === null)
+            throw new CursorNotWriteableException();
+        const position = this.parent.slotPtr.position;
+        this.parent.db.core.seek(position);
+        writer.write(this.slot.toBytes());
+        this.parent.slotPtr = this.parent.slotPtr.withSlot(this.slot);
+    }
+    seek(position) {
+        if (position <= this.size) {
+            this.relativePosition = position;
+        }
+    }
+}
+export class WriteCursorIterator extends CursorIterator {
+    constructor(cursor) {
+        super(cursor);
+    }
+    next() {
+        const readCursor = super.next();
+        if (readCursor !== null) {
+            return new WriteCursor(readCursor.slotPtr, readCursor.db);
+        }
+        else {
+            return null;
+        }
+    }
+}

package/dist/write-hash-map.d.ts

@@ -1,27 +1,26 @@
-import { ReadHashMap } from './read-hash-map';
-import { WriteCursor, WriteCursorIterator } from './write-cursor';
-import type { WriteableData } from './writeable-data';
-import { Bytes } from './writeable-data';
+import { ReadHashMap } from './read-hash-map.js';
+import { WriteCursor, WriteCursorIterator } from './write-cursor.js';
+import type { WriteableData } from './writeable-data.js';
+import { Bytes } from './writeable-data.js';
 export declare class WriteHashMap extends ReadHashMap {
-    protected constructor();
-    static create(cursor: WriteCursor): Promise<WriteHashMap>;
-    iterator(): Promise<WriteCursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    put(key: string, data: WriteableData): Promise<void>;
-    put(key: Bytes, data: WriteableData): Promise<void>;
-    put(hash: Uint8Array, data: WriteableData): Promise<void>;
-    putCursor(key: string): Promise<WriteCursor>;
-    putCursor(key: Bytes): Promise<WriteCursor>;
-    putCursor(hash: Uint8Array): Promise<WriteCursor>;
-    putKey(key: string, data: WriteableData): Promise<void>;
-    putKey(key: Bytes, data: WriteableData): Promise<void>;
-    putKey(hash: Uint8Array, data: WriteableData): Promise<void>;
-    putKeyCursor(key: string): Promise<WriteCursor>;
-    putKeyCursor(key: Bytes): Promise<WriteCursor>;
-    putKeyCursor(hash: Uint8Array): Promise<WriteCursor>;
-    remove(key: string): Promise<boolean>;
-    remove(key: Bytes): Promise<boolean>;
-    remove(hash: Uint8Array): Promise<boolean>;
+    constructor(cursor: WriteCursor, counted?: boolean);
+    iterator(): WriteCursorIterator;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    put(key: string, data: WriteableData): void;
+    put(key: Bytes, data: WriteableData): void;
+    put(hash: Uint8Array, data: WriteableData): void;
+    putCursor(key: string): WriteCursor;
+    putCursor(key: Bytes): WriteCursor;
+    putCursor(hash: Uint8Array): WriteCursor;
+    putKey(key: string, data: WriteableData): void;
+    putKey(key: Bytes, data: WriteableData): void;
+    putKey(hash: Uint8Array, data: WriteableData): void;
+    putKeyCursor(key: string): WriteCursor;
+    putKeyCursor(key: Bytes): WriteCursor;
+    putKeyCursor(hash: Uint8Array): WriteCursor;
+    remove(key: string): boolean;
+    remove(key: Bytes): boolean;
+    remove(hash: Uint8Array): boolean;
     private putInternal;
     private putCursorInternal;
     private putKeyInternal;

package/dist/write-hash-map.js

@@ -0,0 +1,90 @@
+import { ReadHashMap } from './read-hash-map.js';
+import { HashMapInit, HashMapGet, HashMapGetValue, HashMapGetKey, HashMapRemove, WriteData, } from './database.js';
+import { Bytes } from './writeable-data.js';
+import { KeyNotFoundException } from './exceptions.js';
+export class WriteHashMap extends ReadHashMap {
+    constructor(cursor, counted = false) {
+        super();
+        this.cursor = cursor.writePath([new HashMapInit(counted, false)]);
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    put(key, data) {
+        if (typeof key === 'string') {
+            const hash = this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+            this.putKeyInternal(hash, new Bytes(key));
+            this.putInternal(hash, data);
+        }
+        else if (key instanceof Bytes) {
+            const hash = this.cursor.db.hasher.digest(key.value);
+            this.putKeyInternal(hash, key);
+            this.putInternal(hash, data);
+        }
+        else {
+            this.putInternal(key, data);
+        }
+    }
+    putCursor(key) {
+        if (typeof key === 'string') {
+            const hash = this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+            this.putKeyInternal(hash, new Bytes(key));
+            return this.putCursorInternal(hash);
+        }
+        else if (key instanceof Bytes) {
+            const hash = this.cursor.db.hasher.digest(key.value);
+            this.putKeyInternal(hash, key);
+            return this.putCursorInternal(hash);
+        }
+        else {
+            return this.putCursorInternal(key);
+        }
+    }
+    putKey(key, data) {
+        const hash = this.resolveHash(key);
+        this.putKeyInternal(hash, data);
+    }
+    putKeyCursor(key) {
+        const hash = this.resolveHash(key);
+        return this.putKeyCursorInternal(hash);
+    }
+    remove(key) {
+        const hash = this.resolveHash(key);
+        try {
+            this.cursor.writePath([new HashMapRemove(hash)]);
+        }
+        catch (e) {
+            if (e instanceof KeyNotFoundException) {
+                return false;
+            }
+            throw e;
+        }
+        return true;
+    }
+    // Internal methods that take hash directly
+    putInternal(hash, data) {
+        this.cursor.writePath([
+            new HashMapGet(new HashMapGetValue(hash)),
+            new WriteData(data),
+        ]);
+    }
+    putCursorInternal(hash) {
+        return this.cursor.writePath([
+            new HashMapGet(new HashMapGetValue(hash)),
+        ]);
+    }
+    putKeyInternal(hash, data) {
+        const cursor = this.cursor.writePath([
+            new HashMapGet(new HashMapGetKey(hash)),
+        ]);
+        cursor.writeIfEmpty(data);
+    }
+    putKeyCursorInternal(hash) {
+        return this.cursor.writePath([
+            new HashMapGet(new HashMapGetKey(hash)),
+        ]);
+    }
+}

package/dist/write-hash-set.d.ts

@@ -1,21 +1,20 @@
-import { ReadHashSet } from './read-hash-set';
-import { WriteCursor, WriteCursorIterator } from './write-cursor';
-import type { WriteableData } from './writeable-data';
-import { Bytes } from './writeable-data';
+import { ReadHashSet } from './read-hash-set.js';
+import { WriteCursor, WriteCursorIterator } from './write-cursor.js';
+import type { WriteableData } from './writeable-data.js';
+import { Bytes } from './writeable-data.js';
 export declare class WriteHashSet extends ReadHashSet {
-    protected constructor();
-    static create(cursor: WriteCursor): Promise<WriteHashSet>;
-    iterator(): Promise<WriteCursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    put(key: string): Promise<void>;
-    put(key: Bytes): Promise<void>;
-    put(hash: Uint8Array, data: WriteableData): Promise<void>;
-    putCursor(key: string): Promise<WriteCursor>;
-    putCursor(key: Bytes): Promise<WriteCursor>;
-    putCursor(hash: Uint8Array): Promise<WriteCursor>;
-    remove(key: string): Promise<boolean>;
-    remove(key: Bytes): Promise<boolean>;
-    remove(hash: Uint8Array): Promise<boolean>;
+    constructor(cursor: WriteCursor, counted?: boolean);
+    iterator(): WriteCursorIterator;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    put(key: string): void;
+    put(key: Bytes): void;
+    put(hash: Uint8Array, data: WriteableData): void;
+    putCursor(key: string): WriteCursor;
+    putCursor(key: Bytes): WriteCursor;
+    putCursor(hash: Uint8Array): WriteCursor;
+    remove(key: string): boolean;
+    remove(key: Bytes): boolean;
+    remove(hash: Uint8Array): boolean;
     private putInternal;
     private putCursorInternal;
 }

package/dist/write-hash-set.js

@@ -0,0 +1,59 @@
+import { ReadHashSet } from './read-hash-set.js';
+import { HashMapInit, HashMapGet, HashMapGetKey, HashMapRemove } from './database.js';
+import { Bytes } from './writeable-data.js';
+import { KeyNotFoundException } from './exceptions.js';
+export class WriteHashSet extends ReadHashSet {
+    constructor(cursor, counted = false) {
+        super();
+        this.cursor = cursor.writePath([new HashMapInit(counted, true)]);
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    put(key, data) {
+        if (typeof key === 'string') {
+            const bytes = new TextEncoder().encode(key);
+            const hash = this.cursor.db.hasher.digest(bytes);
+            this.putInternal(hash, new Bytes(bytes));
+        }
+        else if (key instanceof Bytes) {
+            const hash = this.cursor.db.hasher.digest(key.value);
+            this.putInternal(hash, key);
+        }
+        else {
+            this.putInternal(key, data);
+        }
+    }
+    putCursor(key) {
+        const hash = this.resolveHash(key);
+        return this.putCursorInternal(hash);
+    }
+    remove(key) {
+        const hash = this.resolveHash(key);
+        try {
+            this.cursor.writePath([new HashMapRemove(hash)]);
+        }
+        catch (e) {
+            if (e instanceof KeyNotFoundException) {
+                return false;
+            }
+            throw e;
+        }
+        return true;
+    }
+    // Internal methods that take hash directly
+    putInternal(hash, data) {
+        const cursor = this.cursor.writePath([
+            new HashMapGet(new HashMapGetKey(hash)),
+        ]);
+        cursor.writeIfEmpty(data);
+    }
+    putCursorInternal(hash) {
+        return this.cursor.writePath([
+            new HashMapGet(new HashMapGetKey(hash)),
+        ]);
+    }
+}

package/dist/write-linked-array-list.d.ts

@@ -1,19 +1,18 @@
-import { Slot } from './slot';
-import { ReadLinkedArrayList } from './read-linked-array-list';
-import { WriteCursor, WriteCursorIterator } from './write-cursor';
-import type { WriteableData } from './writeable-data';
+import { Slot } from './slot.js';
+import { ReadLinkedArrayList } from './read-linked-array-list.js';
+import { WriteCursor, WriteCursorIterator } from './write-cursor.js';
+import type { WriteableData } from './writeable-data.js';
 export declare class WriteLinkedArrayList extends ReadLinkedArrayList {
-    protected constructor();
-    static create(cursor: WriteCursor): Promise<WriteLinkedArrayList>;
-    iterator(): Promise<WriteCursorIterator>;
-    [Symbol.asyncIterator](): AsyncIterator<WriteCursor>;
-    put(index: number, data: WriteableData): Promise<void>;
-    putCursor(index: number): Promise<WriteCursor>;
-    append(data: WriteableData): Promise<void>;
-    appendCursor(): Promise<WriteCursor>;
-    slice(offset: number, size: number): Promise<void>;
-    concat(list: Slot): Promise<void>;
-    insert(index: number, data: WriteableData): Promise<void>;
-    insertCursor(index: number): Promise<WriteCursor>;
-    remove(index: number): Promise<void>;
+    constructor(cursor: WriteCursor);
+    iterator(): WriteCursorIterator;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    put(index: number, data: WriteableData): void;
+    putCursor(index: number): WriteCursor;
+    append(data: WriteableData): void;
+    appendCursor(): WriteCursor;
+    slice(offset: number, size: number): void;
+    concat(list: Slot): void;
+    insert(index: number, data: WriteableData): void;
+    insertCursor(index: number): WriteCursor;
+    remove(index: number): void;
 }

package/dist/write-linked-array-list.js

@@ -0,0 +1,52 @@
+import { ReadLinkedArrayList } from './read-linked-array-list.js';
+import { LinkedArrayListInit, LinkedArrayListGet, LinkedArrayListAppend, LinkedArrayListSlice, LinkedArrayListConcat, LinkedArrayListInsert, LinkedArrayListRemove, WriteData, } from './database.js';
+export class WriteLinkedArrayList extends ReadLinkedArrayList {
+    constructor(cursor) {
+        super();
+        this.cursor = cursor.writePath([new LinkedArrayListInit()]);
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    put(index, data) {
+        this.cursor.writePath([
+            new LinkedArrayListGet(index),
+            new WriteData(data),
+        ]);
+    }
+    putCursor(index) {
+        return this.cursor.writePath([new LinkedArrayListGet(index)]);
+    }
+    append(data) {
+        this.cursor.writePath([
+            new LinkedArrayListAppend(),
+            new WriteData(data),
+        ]);
+    }
+    appendCursor() {
+        return this.cursor.writePath([new LinkedArrayListAppend()]);
+    }
+    slice(offset, size) {
+        this.cursor.writePath([
+            new LinkedArrayListSlice(offset, size),
+        ]);
+    }
+    concat(list) {
+        this.cursor.writePath([new LinkedArrayListConcat(list)]);
+    }
+    insert(index, data) {
+        this.cursor.writePath([
+            new LinkedArrayListInsert(index),
+            new WriteData(data),
+        ]);
+    }
+    insertCursor(index) {
+        return this.cursor.writePath([new LinkedArrayListInsert(index)]);
+    }
+    remove(index) {
+        this.cursor.writePath([new LinkedArrayListRemove(index)]);
+    }
+}

package/dist/write-sorted-map.d.ts

@@ -0,0 +1,12 @@
+import { ReadSortedMap } from './read-sorted-map.js';
+import { WriteCursor, WriteCursorIterator } from './write-cursor.js';
+import type { WriteableData } from './writeable-data.js';
+import { Bytes } from './writeable-data.js';
+export declare class WriteSortedMap extends ReadSortedMap {
+    constructor(cursor: WriteCursor);
+    iterator(): WriteCursorIterator;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    put(key: string | Bytes | Uint8Array, data: WriteableData): void;
+    putCursor(key: string | Bytes | Uint8Array): WriteCursor;
+    remove(key: string | Bytes | Uint8Array): boolean;
+}

package/dist/write-sorted-map.js

@@ -0,0 +1,37 @@
+import { ReadSortedMap } from './read-sorted-map.js';
+import { SortedMapInit, SortedMapGet, SortedMapGetValue, SortedMapRemove, WriteData, } from './database.js';
+import { KeyNotFoundException } from './exceptions.js';
+export class WriteSortedMap extends ReadSortedMap {
+    constructor(cursor) {
+        super();
+        this.cursor = cursor.writePath([new SortedMapInit(false)]);
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    put(key, data) {
+        this.cursor.writePath([
+            new SortedMapGet(new SortedMapGetValue(this.resolveKey(key))),
+            new WriteData(data),
+        ]);
+    }
+    putCursor(key) {
+        return this.cursor.writePath([
+            new SortedMapGet(new SortedMapGetValue(this.resolveKey(key))),
+        ]);
+    }
+    remove(key) {
+        try {
+            this.cursor.writePath([new SortedMapRemove(this.resolveKey(key))]);
+        }
+        catch (e) {
+            if (e instanceof KeyNotFoundException)
+                return false;
+            throw e;
+        }
+        return true;
+    }
+}

package/dist/write-sorted-set.d.ts

@@ -0,0 +1,10 @@
+import { ReadSortedSet } from './read-sorted-set.js';
+import { WriteCursor, WriteCursorIterator } from './write-cursor.js';
+import { Bytes } from './writeable-data.js';
+export declare class WriteSortedSet extends ReadSortedSet {
+    constructor(cursor: WriteCursor);
+    iterator(): WriteCursorIterator;
+    [Symbol.iterator](): Iterator<WriteCursor>;
+    put(key: string | Bytes | Uint8Array): void;
+    remove(key: string | Bytes | Uint8Array): boolean;
+}

package/dist/write-sorted-set.js

@@ -0,0 +1,29 @@
+import { ReadSortedSet } from './read-sorted-set.js';
+import { SortedMapInit, SortedMapGet, SortedMapGetKey, SortedMapRemove } from './database.js';
+import { KeyNotFoundException } from './exceptions.js';
+export class WriteSortedSet extends ReadSortedSet {
+    constructor(cursor) {
+        super();
+        this.cursor = cursor.writePath([new SortedMapInit(true)]);
+    }
+    iterator() {
+        return this.cursor.iterator();
+    }
+    *[Symbol.iterator]() {
+        yield* this.cursor;
+    }
+    put(key) {
+        this.cursor.writePath([new SortedMapGet(new SortedMapGetKey(this.resolveKey(key)))]);
+    }
+    remove(key) {
+        try {
+            this.cursor.writePath([new SortedMapRemove(this.resolveKey(key))]);
+        }
+        catch (e) {
+            if (e instanceof KeyNotFoundException)
+                return false;
+            throw e;
+        }
+        return true;
+    }
+}

package/dist/writeable-data.js

@@ -0,0 +1,68 @@
+import { InvalidFormatTagSizeException, Uint64OverflowException, Int64OverflowException } from './exceptions.js';
+const UINT64_MAX = 2n ** 64n - 1n;
+const INT64_MIN = -(2n ** 63n);
+const INT64_MAX = 2n ** 63n - 1n;
+export class Uint {
+    value;
+    constructor(value) {
+        const bigintValue = BigInt(value);
+        if (bigintValue < 0n || bigintValue > UINT64_MAX) {
+            throw new Uint64OverflowException();
+        }
+        this.value = bigintValue;
+    }
+}
+export class Int {
+    value;
+    constructor(value) {
+        const bigintValue = BigInt(value);
+        if (bigintValue < INT64_MIN || bigintValue > INT64_MAX) {
+            throw new Int64OverflowException();
+        }
+        this.value = bigintValue;
+    }
+}
+export class Float {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+export class Bytes {
+    value;
+    formatTag;
+    constructor(value, formatTag) {
+        if (typeof value === 'string') {
+            this.value = new TextEncoder().encode(value);
+        }
+        else {
+            this.value = value;
+        }
+        if (formatTag === undefined || formatTag === null) {
+            this.formatTag = null;
+        }
+        else if (typeof formatTag === 'string') {
+            const encoded = new TextEncoder().encode(formatTag);
+            if (encoded.length !== 2) {
+                throw new InvalidFormatTagSizeException();
+            }
+            this.formatTag = encoded;
+        }
+        else {
+            if (formatTag.length !== 2) {
+                throw new InvalidFormatTagSizeException();
+            }
+            this.formatTag = formatTag;
+        }
+    }
+    isShort() {
+        const totalSize = this.formatTag !== null ? 6 : 8;
+        if (this.value.length > totalSize)
+            return false;
+        for (const b of this.value) {
+            if (b === 0)
+                return false;
+        }
+        return true;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xitdb",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "An immutable database",
   "license": "MIT",
   "repository": {
@@ -21,14 +21,14 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
-    "build:types": "tsc --emitDeclarationOnly",
-    "prepublishOnly": "bun run build && bun run build:types",
-    "test": "bun test",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "tsx --test tests/*.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@types/bun": "latest",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
     "typescript": "^5.3.0"
   }
 }