xitdb 0.1.0 → 0.2.0

package/src/read-hash-set.ts

@@ -1,70 +0,0 @@
-import { Tag } from './tag';
-import { Slot } from './slot';
-import type { Slotted } from './slotted';
-import { ReadCursor, CursorIterator } from './read-cursor';
-import { HashMapGet, HashMapGetKey } from './database';
-import { UnexpectedTagException } from './exceptions';
-import { Bytes } from './writeable-data';
-
-export class ReadHashSet implements Slotted {
-  public cursor!: ReadCursor;
-
-  protected constructor() {}
-
-  static async create(cursor: ReadCursor): Promise<ReadHashSet> {
-    const set = new ReadHashSet();
-    switch (cursor.slotPtr.slot.tag) {
-      case Tag.NONE:
-      case Tag.HASH_MAP:
-      case Tag.HASH_SET:
-        set.cursor = cursor;
-        break;
-      default:
-        throw new UnexpectedTagException();
-    }
-    return set;
-  }
-
-  slot(): Slot {
-    return this.cursor.slot();
-  }
-
-  iterator(): CursorIterator {
-    return this.cursor.iterator();
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterator<ReadCursor> {
-    yield* this.cursor;
-  }
-
-  // Methods that take a string key and hash it
-  async getCursorByString(key: string): Promise<ReadCursor | null> {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.getCursor(hash);
-  }
-
-  async getSlotByString(key: string): Promise<Slot | null> {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.getSlot(hash);
-  }
-
-  // Methods that take Bytes key and hash it
-  async getCursorByBytes(key: Bytes): Promise<ReadCursor | null> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.getCursor(hash);
-  }
-
-  async getSlotByBytes(key: Bytes): Promise<Slot | null> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.getSlot(hash);
-  }
-
-  // Methods that take hash directly
-  async getCursor(hash: Uint8Array): Promise<ReadCursor | null> {
-    return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
-  }
-
-  async getSlot(hash: Uint8Array): Promise<Slot | null> {
-    return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
-  }
-}

package/src/read-linked-array-list.ts

@@ -1,45 +0,0 @@
-import { Tag } from './tag';
-import { Slot } from './slot';
-import type { Slotted } from './slotted';
-import { ReadCursor, CursorIterator } from './read-cursor';
-import { LinkedArrayListGet } from './database';
-import { UnexpectedTagException } from './exceptions';
-
-export class ReadLinkedArrayList implements Slotted {
-  public cursor: ReadCursor;
-
-  constructor(cursor: ReadCursor) {
-    switch (cursor.slotPtr.slot.tag) {
-      case Tag.NONE:
-      case Tag.LINKED_ARRAY_LIST:
-        this.cursor = cursor;
-        break;
-      default:
-        throw new UnexpectedTagException();
-    }
-  }
-
-  slot(): Slot {
-    return this.cursor.slot();
-  }
-
-  async count(): Promise<number> {
-    return this.cursor.count();
-  }
-
-  iterator(): CursorIterator {
-    return this.cursor.iterator();
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterator<ReadCursor> {
-    yield* this.cursor;
-  }
-
-  async getCursor(index: number): Promise<ReadCursor | null> {
-    return this.cursor.readPath([new LinkedArrayListGet(index)]);
-  }
-
-  async getSlot(index: number): Promise<Slot | null> {
-    return this.cursor.readPathSlot([new LinkedArrayListGet(index)]);
-  }
-}

package/src/slot-pointer.ts

@@ -1,15 +0,0 @@
-import { Slot } from './slot';
-
-export class SlotPointer {
-  readonly position: number | null;
-  readonly slot: Slot;
-
-  constructor(position: number | null, slot: Slot) {
-    this.position = position;
-    this.slot = slot;
-  }
-
-  withSlot(slot: Slot): SlotPointer {
-    return new SlotPointer(this.position, slot);
-  }
-}

package/src/slot.ts

@@ -1,51 +0,0 @@
-import { Tag, tagValueOf } from './tag';
-import type { WriteableData } from './writeable-data';
-
-export class Slot implements WriteableData {
-  static readonly LENGTH = 9;
-
-  readonly value: bigint;
-  readonly tag: Tag;
-  readonly full: boolean;
-
-  constructor(value: number | bigint = 0n, tag: Tag = Tag.NONE, full: boolean = false) {
-    this.value = typeof value === 'bigint' ? value : BigInt(value);
-    this.tag = tag;
-    this.full = full;
-  }
-
-  withTag(tag: Tag): Slot {
-    return new Slot(this.value, tag, this.full);
-  }
-
-  withFull(full: boolean): Slot {
-    return new Slot(this.value, this.tag, full);
-  }
-
-  empty(): boolean {
-    return this.tag === Tag.NONE && !this.full;
-  }
-
-  toBytes(): Uint8Array {
-    const buffer = new ArrayBuffer(Slot.LENGTH);
-    const view = new DataView(buffer);
-    let tagInt = this.full ? 0b1000_0000 : 0;
-    tagInt = tagInt | this.tag;
-    view.setUint8(0, tagInt);
-    view.setBigInt64(1, this.value, false);
-    return new Uint8Array(buffer);
-  }
-
-  static fromBytes(bytes: Uint8Array): Slot {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const tagByte = view.getUint8(0);
-    const full = (tagByte & 0b1000_0000) !== 0;
-    const tag = tagValueOf(tagByte & 0b0111_1111);
-    const value = view.getBigInt64(1, false);
-    return new Slot(value, tag, full);
-  }
-
-  equals(other: Slot): boolean {
-    return this.value === other.value && this.tag === other.tag && this.full === other.full;
-  }
-}

package/src/tag.ts

@@ -1,23 +0,0 @@
-export const enum Tag {
-  NONE = 0,
-  INDEX = 1,
-  ARRAY_LIST = 2,
-  LINKED_ARRAY_LIST = 3,
-  HASH_MAP = 4,
-  KV_PAIR = 5,
-  BYTES = 6,
-  SHORT_BYTES = 7,
-  UINT = 8,
-  INT = 9,
-  FLOAT = 10,
-  HASH_SET = 11,
-  COUNTED_HASH_MAP = 12,
-  COUNTED_HASH_SET = 13,
-}
-
-export function tagValueOf(n: number): Tag {
-  if (n < 0 || n > 13) {
-    throw new Error(`Invalid tag value: ${n}`);
-  }
-  return n as Tag;
-}

package/src/write-array-list.ts

@@ -1,65 +0,0 @@
-import { ReadArrayList } from './read-array-list';
-import { WriteCursor, WriteCursorIterator } from './write-cursor';
-import {
-  ArrayListInit,
-  ArrayListGet,
-  ArrayListAppend,
-  ArrayListSlice,
-  WriteData,
-  Context,
-  type ContextFunction,
-} from './database';
-import type { WriteableData } from './writeable-data';
-
-export class WriteArrayList extends ReadArrayList {
-  constructor(cursor: WriteCursor) {
-    super(cursor);
-  }
-
-  static async create(cursor: WriteCursor): Promise<WriteArrayList> {
-    const newCursor = await cursor.writePath([new ArrayListInit()]);
-    return new WriteArrayList(newCursor);
-  }
-
-  override iterator(): WriteCursorIterator {
-    return (this.cursor as WriteCursor).iterator();
-  }
-
-  override async *[Symbol.asyncIterator](): AsyncIterator<WriteCursor> {
-    yield* this.cursor as WriteCursor;
-  }
-
-  async put(index: number, data: WriteableData): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([
-      new ArrayListGet(index),
-      new WriteData(data),
-    ]);
-  }
-
-  async putCursor(index: number): Promise<WriteCursor> {
-    return (this.cursor as WriteCursor).writePath([new ArrayListGet(index)]);
-  }
-
-  async append(data: WriteableData): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([
-      new ArrayListAppend(),
-      new WriteData(data),
-    ]);
-  }
-
-  async appendCursor(): Promise<WriteCursor> {
-    return (this.cursor as WriteCursor).writePath([new ArrayListAppend()]);
-  }
-
-  async appendContext(data: WriteableData | null, fn: ContextFunction): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([
-      new ArrayListAppend(),
-      new WriteData(data),
-      new Context(fn),
-    ]);
-  }
-
-  async slice(size: number): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([new ArrayListSlice(size)]);
-  }
-}

package/src/write-counted-hash-map.ts

@@ -1,31 +0,0 @@
-import { Tag } from './tag';
-import { WriteHashMap } from './write-hash-map';
-import { WriteCursor } from './write-cursor';
-import { HashMapInit } from './database';
-import { UnexpectedTagException } from './exceptions';
-
-export class WriteCountedHashMap extends WriteHashMap {
-  protected constructor() {
-    super();
-  }
-
-  static override async create(cursor: WriteCursor): Promise<WriteCountedHashMap> {
-    const map = new WriteCountedHashMap();
-    switch (cursor.slotPtr.slot.tag) {
-      case Tag.NONE:
-      case Tag.COUNTED_HASH_MAP:
-      case Tag.COUNTED_HASH_SET: {
-        const newCursor = await cursor.writePath([new HashMapInit(true, false)]);
-        map.cursor = newCursor;
-        break;
-      }
-      default:
-        throw new UnexpectedTagException();
-    }
-    return map;
-  }
-
-  async count(): Promise<number> {
-    return this.cursor.count();
-  }
-}

package/src/write-counted-hash-set.ts

@@ -1,31 +0,0 @@
-import { Tag } from './tag';
-import { WriteHashSet } from './write-hash-set';
-import { WriteCursor } from './write-cursor';
-import { HashMapInit } from './database';
-import { UnexpectedTagException } from './exceptions';
-
-export class WriteCountedHashSet extends WriteHashSet {
-  protected constructor() {
-    super();
-  }
-
-  static override async create(cursor: WriteCursor): Promise<WriteCountedHashSet> {
-    const set = new WriteCountedHashSet();
-    switch (cursor.slotPtr.slot.tag) {
-      case Tag.NONE:
-      case Tag.COUNTED_HASH_MAP:
-      case Tag.COUNTED_HASH_SET: {
-        const newCursor = await cursor.writePath([new HashMapInit(true, true)]);
-        set.cursor = newCursor;
-        break;
-      }
-      default:
-        throw new UnexpectedTagException();
-    }
-    return set;
-  }
-
-  async count(): Promise<number> {
-    return this.cursor.count();
-  }
-}

package/src/write-cursor.ts

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

package/src/write-hash-map.ts

@@ -1,129 +0,0 @@
-import { ReadHashMap } from './read-hash-map';
-import { WriteCursor, WriteCursorIterator, WriteKeyValuePairCursor } from './write-cursor';
-import {
-  HashMapInit,
-  HashMapGet,
-  HashMapGetValue,
-  HashMapGetKey,
-  HashMapRemove,
-  WriteData,
-} from './database';
-import type { WriteableData } from './writeable-data';
-import { Bytes } from './writeable-data';
-import { KeyNotFoundException } from './exceptions';
-
-export class WriteHashMap extends ReadHashMap {
-  protected constructor() {
-    super();
-  }
-
-  static async create(cursor: WriteCursor): Promise<WriteHashMap> {
-    const map = new WriteHashMap();
-    const newCursor = await cursor.writePath([new HashMapInit(false, false)]);
-    map.cursor = newCursor;
-    return map;
-  }
-
-  override iterator(): WriteCursorIterator {
-    return (this.cursor as WriteCursor).iterator();
-  }
-
-  override async *[Symbol.asyncIterator](): AsyncIterator<WriteCursor> {
-    yield* this.cursor as WriteCursor;
-  }
-
-  // Methods that take a string key and hash it
-  async putByString(key: string, data: WriteableData): Promise<void> {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    await this.putKey(hash, new Bytes(key));
-    await this.put(hash, data);
-  }
-
-  async putCursorByString(key: string): Promise<WriteCursor> {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    await this.putKey(hash, new Bytes(key));
-    return this.putCursor(hash);
-  }
-
-  async putKeyByString(key: string, data: WriteableData): Promise<void> {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    await this.putKey(hash, data);
-  }
-
-  async putKeyCursorByString(key: string): Promise<WriteCursor> {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.putKeyCursor(hash);
-  }
-
-  async removeByString(key: string): Promise<boolean> {
-    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    return this.remove(hash);
-  }
-
-  // Methods that take Bytes key and hash it
-  async putByBytes(key: Bytes, data: WriteableData): Promise<void> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    await this.putKey(hash, key);
-    await this.put(hash, data);
-  }
-
-  async putCursorByBytes(key: Bytes): Promise<WriteCursor> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    await this.putKey(hash, key);
-    return this.putCursor(hash);
-  }
-
-  async putKeyByBytes(key: Bytes, data: WriteableData): Promise<void> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    await this.putKey(hash, data);
-  }
-
-  async putKeyCursorByBytes(key: Bytes): Promise<WriteCursor> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.putKeyCursor(hash);
-  }
-
-  async removeByBytes(key: Bytes): Promise<boolean> {
-    const hash = await this.cursor.db.hasher.digest(key.value);
-    return this.remove(hash);
-  }
-
-  // Methods that take hash directly
-  async put(hash: Uint8Array, data: WriteableData): Promise<void> {
-    await (this.cursor as WriteCursor).writePath([
-      new HashMapGet(new HashMapGetValue(hash)),
-      new WriteData(data),
-    ]);
-  }
-
-  async putCursor(hash: Uint8Array): Promise<WriteCursor> {
-    return (this.cursor as WriteCursor).writePath([
-      new HashMapGet(new HashMapGetValue(hash)),
-    ]);
-  }
-
-  async putKey(hash: Uint8Array, data: WriteableData): Promise<void> {
-    const cursor = await (this.cursor as WriteCursor).writePath([
-      new HashMapGet(new HashMapGetKey(hash)),
-    ]);
-    await cursor.writeIfEmpty(data);
-  }
-
-  async putKeyCursor(hash: Uint8Array): Promise<WriteCursor> {
-    return (this.cursor as WriteCursor).writePath([
-      new HashMapGet(new HashMapGetKey(hash)),
-    ]);
-  }
-
-  async remove(hash: Uint8Array): Promise<boolean> {
-    try {
-      await (this.cursor as WriteCursor).writePath([new HashMapRemove(hash)]);
-    } catch (e) {
-      if (e instanceof KeyNotFoundException) {
-        return false;
-      }
-      throw e;
-    }
-    return true;
-  }
-}