@glmachado/any-store 0.3.0 → 0.4.0

package/dist/lib.es.js

@@ -128,7 +128,7 @@ var ops = {
 		return this.memory.buffer.byteLength / 2 ** 16;
 	}
 	createTable(e, _) {
-		return new Table(e, this.ops.createTable(_), this);
+		return new Table(_, this.ops.createTable(e), this);
 	}
 	insertRowOnTable(e, _, v) {
 		v.forEach((e) => {

package/dist/src/WDB.d.ts

@@ -17,7 +17,7 @@ export declare class AnyStore {
     static fromModule(workerData: WorkerData): Promise<AnyStore>;
     getTable<T extends ColMap>(name: string, colMap: T): Table<T> | null;
     memSize(): number;
-    createTable<T extends ColMap>(colMap: T, name: string): Table<T>;
+    createTable<T extends ColMap>(name: string, colMap: T): Table<T>;
     insertRowOnTable(tableID: number, key: Something, values: Something[]): void;
     insertOnTable(tableID: number, col: number, key: Something, value: Something): void;
     addListenerToRow(tableID: number, key: Something, fn: () => void): number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@glmachado/any-store",
   "private": false,
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "files": [
     "dist"
@@ -16,12 +16,13 @@
   },
   "scripts": {
     "dev": "vite",
-    "build": "tsc && vite build",
+    "build": "npm run check && vite build",
     "preview": "vite preview",
+    "check": "tsc --build",
     "test": "vitest",
     "bench": "vitest bench",
     "test:browser": "vitest --config=vitest.browser.config.ts",
-    "test-ci": "cargo wasm && vitest --run & vitest --config=vitest.browser.config.ts --run & cargo test",
+    "test-ci": "cargo wasm && vitest --run & vitest --config=vitest.browser.config.ts --run --browser.headless & cargo test",
     "publish": "npm run build && npm run test-ci && npm publish --access public"
   },
   "devDependencies": {

package/readme.md

@@ -1,59 +1,215 @@
 ## Any Store
 
-This package provides a simple in memory, embedded database with key-value storage. The main advantage of using this database is that with it you can share data between different threads and workers without the cost of for serialization. Data can be written and read in worker threads and the main thread.
+A simple in-memory, embedded database with key-value storage. Share data between different threads and workers without serialization costs. Data can be written and read from worker threads and the main thread using shared WebAssembly memory.
 
-### Usage
+## Installation
+
+```bash
+npm install @glmachado/any-store
+```
+
+## Basic Usage
 
 ```ts
-import { WDB } from "@glmachado/any-store";
+import { AnyStore } from "@glmachado/any-store";
+
+// Create a database
+const db = await AnyStore.create();
 
-const db = await WDB.create();
-const table = db.createTable({
-  counter: "i32",
+// Create a table with name and schema
+const table = db.createTable("users", {
+  name: "string",
+  age: "i32",
+  height: "f64",
 });
-const row = table.row(WDB.i32(1));
 
-console.log(row.get("counter")); // null
+// Get a row handle
+const row = table.row(AnyStore.i32(1));
 
-row.update("counter", WDB.i32(0));
-db.commit();
+// Update values
+row.update("name", AnyStore.string("Alice"));
+row.update("age", AnyStore.i32(30));
+row.update("height", AnyStore.f64(1.75));
 
-console.log(row.get("counter")); // 0
+// Read values
+console.log(row.get("name")); // "Alice"
+console.log(row.get("age")); // 30
+console.log(row.get("height")); // 1.75
+
+// Delete a row
+row.delete();
+console.log(row.get("name")); // null
 ```
 
-## Usage with workers
+## Data Types
+
+The library supports the following data types:
+
+- `AnyStore.i32(number)` - 32-bit integer
+- `AnyStore.f64(number)` - 64-bit float
+- `AnyStore.string(string)` - UTF-8 string
+- `AnyStore.blob(Uint8Array)` - Binary data
+- `AnyStore.null()` - Null value
+
+## Table Operations
 
 ```ts
-// in main thread
-import { WDB } from "@glmachado/any-store";
+const table = db.createTable("products", {
+  name: "string",
+  price: "f64",
+  stock: "i32",
+});
+
+// Insert individual columns
+const key = AnyStore.i32(1);
+table.insert(key, AnyStore.string("Laptop"), "name");
+table.insert(key, AnyStore.f64(999.99), "price");
+table.insert(key, AnyStore.i32(5), "stock");
+
+// Insert a complete row at once
+table.insertRow(
+  AnyStore.i32(2),
+  [
+    AnyStore.string("Mouse"),
+    AnyStore.f64(29.99),
+    AnyStore.i32(100),
+  ]
+);
 
-const db = await WDB.create();
-const table = db.createTable({
-  counter: "i32",
+// Get a single value
+const price = table.get(key, "price"); // 999.99
+
+// Get the entire row
+const row = table.getRow(key); // ["Laptop", 999.99, 5]
+
+// Delete a row
+table.deleteRow(key);
+```
+
+## Reactive Updates with Listeners
+
+```ts
+const table = db.createTable("counter", { value: "i32" });
+const row = table.row(AnyStore.i32(1));
+
+// Add a listener to be notified when the row changes
+const listenerID = row.addListener(() => {
+  console.log("Row changed:", row.get("value"));
 });
-const row = table.row(WDB.i32(1));
-row.update("counter", WDB.i32(10));
-db.commit();
-
-const worker = new Worker("./example.worker.js");
-worker.postMessage({
-  module: db.getModule(),
-  memory: db.getMemory(),
+
+// Update triggers the listener on next notifyAll()
+row.update("value", AnyStore.i32(10));
+db.notifyAll(); // Triggers all listeners
+
+// Remove the listener
+row.removeListener(listenerID);
+```
+
+## Cached Rows
+
+Use cached rows for better performance when reading values frequently:
+
+```ts
+const row = table.row(AnyStore.i32(1));
+
+// Enable caching with optional update callback
+row.cached(() => {
+  console.log("Cache updated:", row.get("value"));
 });
+
+row.update("value", AnyStore.i32(10));
+console.log(row.get("value")); // Still old value until notified
+
+db.notifyAll(); // Updates cache and triggers callback
+console.log(row.get("value")); // 10 (from cache)
 ```
 
+## Usage with Workers
+
+Share the database across multiple threads without serialization:
+
 ```ts
-// in worker thread
-import { WDB } from "@glmachado/any-store";
+// Main thread
+import { AnyStore } from "@glmachado/any-store";
+
+const db = await AnyStore.create(0); // Worker ID 0 for main thread
+const table = db.createTable("shared", { counter: "i32" });
+
+const row = table.row(AnyStore.i32(1));
+row.update("counter", AnyStore.i32(0));
+
+// Create worker data to share
+const workerData = db.createWorker();
+
+const worker = new Worker("./worker.js");
+worker.postMessage(workerData);
+```
+
+```ts
+// Worker thread (worker.js)
+import { AnyStore } from "@glmachado/any-store";
 
 self.onmessage = async (event) => {
-  const module = event.data.module;
-  const memory = event.data.memory;
-  const db = await WDB.fromModule(module, memory, 1);
+  const workerData = event.data;
+  const db = await AnyStore.fromModule(workerData);
   
-  //this will read data from the table created in the main thread
-  const table = db.getTable(1, { counter: "i32" });
-  const row = table.row(WDB.i32(1));
-  console.log(row.get("counter")); // 10
+  // Access the table created in the main thread
+  const table = db.getTable("shared", { counter: "i32" });
+  if (!table) {
+    throw new Error("Table not found");
+  }
+  
+  const row = table.row(AnyStore.i32(1));
+  
+  // Read and modify shared data
+  db.withLock(() => {
+    const current = row.get("counter") as number;
+    row.update("counter", AnyStore.i32(current + 1));
+  });
 };
-```
+```
+
+## Thread Safety
+
+Use `withLock()` to ensure atomic operations when accessing shared data:
+
+```ts
+db.withLock(() => {
+  const current = row.get("counter") as number;
+  row.update("counter", AnyStore.i32(current + 1));
+});
+```
+
+## API Reference
+
+### AnyStore
+
+- `static create(id?: number, bufferSource?: BufferSource): Promise<AnyStore>` - Create a new database
+- `static fromModule(workerData: WorkerData): Promise<AnyStore>` - Create from worker data
+- `createTable<T>(name: string, colMap: T): Table<T>` - Create a new table
+- `getTable<T>(name: string, colMap: T): Table<T> | null` - Get an existing table by name
+- `createWorker(): WorkerData` - Create worker data for sharing
+- `withLock<T>(fn: () => T): T` - Execute function with lock
+- `notifyAll(): void` - Notify all listeners
+- `memSize(): number` - Get memory size in pages
+
+### Table
+
+- `row(key: Something): Row` - Get a row handle
+- `insert(key: Something, value: Something, colName: string): void` - Insert a value
+- `insertRow(key: Something, values: Something[]): void` - Insert a complete row
+- `get(key: Something, colName: string): any` - Get a value
+- `getRow(key: Something): any[]` - Get all values in a row
+- `deleteRow(key: Something): void` - Delete a row
+- `addListenerToRow(key: Something, fn: () => void): number` - Add a listener
+- `removeListenerFromRow(key: Something, listenerID: number): void` - Remove a listener
+
+### Row
+
+- `get(colName: string): any` - Get a column value
+- `update(colName: string, value: Something): void` - Update a column
+- `delete(): void` - Delete the row
+- `getRow(): any[]` - Get all values
+- `addListener(fn: () => void): number` - Add a listener
+- `cached(onUpdate?: () => void): number` - Enable caching
+- `removeListener(listenerID: number): void` - Remove a listener