toilscript 0.1.61 → 0.1.63

package/dist/web.js

@@ -1,8 +1,8 @@
-var ASSEMBLYSCRIPT_VERSION = "0.1.61";
+var ASSEMBLYSCRIPT_VERSION = "0.1.63";
   var ASSEMBLYSCRIPT_IMPORTMAP = {
   "imports": {
-    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.61/dist/toilscript.js",
-    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.61/dist/cli.js",
+    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.63/dist/toilscript.js",
+    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.63/dist/cli.js",
     "binaryen": "https://cdn.jsdelivr.net/npm/binaryen@130.0.0/index.js",
     "long": "https://cdn.jsdelivr.net/npm/long@5.3.2/index.js"
   }

package/package.json

@@ -8,7 +8,7 @@
     "toilscript",
     "wasm"
   ],
-  "version": "0.1.61",
+  "version": "0.1.63",
   "author": "Daniel Wirtz <dcode+assemblyscript@dcode.io>",
   "license": "Apache-2.0",
   "homepage": "https://github.com/dacely-cloud/toilscript",
@@ -72,6 +72,7 @@
     "toilinit": "./bin/toilinit.js"
   },
   "scripts": {
+    "prepare": "node scripts/build",
     "check": "npm run check:config && npm run check:import && npm run lint",
     "check:config": "tsc --noEmit -p src --diagnostics --listFiles",
     "check:import": "tsc --noEmit --skipLibCheck --target ESNEXT --module nodenext --moduleResolution nodenext --experimentalDecorators tests/import/index",
@@ -80,7 +81,7 @@
     "prepublishOnly": "node scripts/build",
     "watch": "node scripts/build --watch",
     "coverage": "npx c8 -- npm test",
-    "test": "npm run test:parser && npm run test:compiler -- --parallel && npm run test:browser && npm run test:toilconfig && npm run test:transform && npm run test:cli && npm run test:json && npm run test:data && npm run test:dbresolve && npm run test:dbstatic && npm run test:routekinds && npm run test:derive && npm run test:streams && npm run test:daemon && npm run test:dberror",
+    "test": "npm run test:parser && npm run test:compiler -- --parallel && npm run test:browser && npm run test:toilconfig && npm run test:transform && npm run test:cli && npm run test:json && npm run test:data && npm run test:dbresolve && npm run test:dbstatic && npm run test:dbtypes && npm run test:routekinds && npm run test:derive && npm run test:streams && npm run test:daemon && npm run test:dberror && npm run test:events && npm run test:uniquebatch",
     "test:parser": "node --enable-source-maps tests/parser",
     "test:compiler": "node --enable-source-maps --no-warnings tests/compiler",
     "test:browser": "node --enable-source-maps tests/browser",
@@ -93,10 +94,13 @@
     "test:data": "node tests/data/run.mjs",
     "test:dbresolve": "node tests/dbresolve/run.mjs",
     "test:dbstatic": "node tests/dbstatic/run.mjs",
+    "test:dbtypes": "node tests/dbtypes/run.mjs",
     "test:routekinds": "node tests/routekinds/run.mjs",
     "test:derive": "node tests/derive/run.mjs",
     "test:streams": "node tests/streams/run.mjs && node tests/streams/catalog.mjs && node tests/streams/codegen.mjs",
     "test:daemon": "node tests/daemon/run.mjs",
+    "test:uniquebatch": "node tests/uniquebatch/run.mjs",
+    "test:events": "node tests/events/run.mjs",
     "test:dberror": "node tests/dberror/run.mjs",
     "asbuild": "npm run asbuild:debug && npm run asbuild:release",
     "asbuild:debug": "node bin/toilscript --config src/toilconfig.json --target debug",

package/std/assembly/bindings/toildb.ts

@@ -230,6 +230,16 @@ export namespace toildbHost {
     idemPtr: usize
   ): i32;
 
+  // Point reads: stashed value length | -2 absent | typed negative error.
+  // result_schema_version exposes the stored event's schema version.
+  // @ts-ignore: decorator
+  @external("env", "data.events_get")
+  export declare function eventsGet(handle: u32, keyPtr: usize, keyLen: i32, evidPtr: usize, evidLen: i32): i32;
+
+  // @ts-ignore: decorator
+  @external("env", "data.events_last")
+  export declare function eventsLast(handle: u32, keyPtr: usize, keyLen: i32): i32;
+
   // events.latest(limit) -> framed-list length (stashed) | negative error.
   // The blob is `u32 count` then per event `u32 schema_version + u32 len + bytes`,
   // newest first.

package/std/assembly/toildb.ts

@@ -186,7 +186,8 @@ function __toildbMiss(status: i32): void {
 /// }
 /// ```
 ///
-/// ONLY `Documents.get`, `Documents.getDelete`, `View.get` and `Unique.lookup`
+/// `Documents.get`, `Documents.getDelete`, `View.get`, `Unique.lookup`,
+/// `Events.get` and `Events.last`
 /// record into this. Every other ToilDB op either succeeds or traps. The `Analytics`
 /// reads also answer `null`, but on their own `-2 absent` / `-3 forbidden` statuses
 /// rather than a `TDLnnn`, so they leave `lastError()` untouched: do not consult it
@@ -325,8 +326,9 @@ export class Documents<K, V> {
   /// conflict or retry - the later one wins and overwrites the earlier. Correct
   /// for writing a whole value (a profile, a settings blob); wrong for a
   /// read-modify-write of accumulating state (a balance, a like count), where a
-  /// concurrent write would be lost - use `counter.add` or version-checked
-  /// `patch` there. A lost write is a data-integrity concern, not a boundary one:
+  /// concurrent write would be lost - use `counter.add` or a caller-observed
+  /// conditional write there. A lost write is a data-integrity concern, not a
+  /// boundary one:
   /// the key is tenant-scoped, so a race is only ever one tenant's own concurrent
   /// writes, and `@unique` stays race-safe (claim-once at the value's home).
   upsert(key: K, value: V): UpsertResult {
@@ -352,9 +354,9 @@ export class Documents<K, V> {
     return v;
   }
 
-  /// Atomically replace an EXISTING record's value, version-checked: returns true
-  /// if applied, false if a concurrent write changed the record first (optimistic
-  /// concurrency - re-read and retry) or the record is absent.
+  /// Submit a replacement of an EXISTING record: true when accepted, false on
+  /// absence or rejection. The ABI carries no caller-observed version or value,
+  /// so this cannot protect a read-modify-write based on an earlier application read.
   enqueue(key: K, value: V): bool {
     const kb = key.encode();
     const vb = value.encode();
@@ -446,6 +448,12 @@ export class Unique<K, V> {
     return v;
   }
 
+  /// Bounded owner lookup in input order, with null for each unclaimed key.
+  /// Uses one read operation; the host enforces the per-request batch limit.
+  lookupMany(keys: K[]): Array<V | null> {
+    return new Documents<K, V>(this.__handle).getMany(keys);
+  }
+
   /// Claim `key` for `value`. Returns whether the caller owns it, and (when
   /// another owns it) who.
   claim(key: K, value: V): ClaimResult<V> {
@@ -944,6 +952,27 @@ export class Events<K, V> {
     this.__handle = handle;
   }
 
+  /// Read an event by its appendOnce eventId, or null if absent. Bounded request-path read.
+  get(key: K, eventId: string): V | null {
+    const kb = key.encode();
+    const idb = Uint8Array.wrap(String.UTF8.encode(eventId));
+    const status = toildbHost.eventsGet(this.__handle, kb.dataStart, kb.byteLength, idb.dataStart, idb.byteLength);
+    if (status < 0) { __toildbMiss(status); return null; }
+    const v = instantiate<V>();
+    v.decodeInto(__toildbTake(status));
+    return v;
+  }
+
+  /// Read the newest appended event, or null for an empty stream. Does not scan.
+  last(key: K): V | null {
+    const kb = key.encode();
+    const status = toildbHost.eventsLast(this.__handle, kb.dataStart, kb.byteLength);
+    if (status < 0) { __toildbMiss(status); return null; }
+    const v = instantiate<V>();
+    v.decodeInto(__toildbTake(status));
+    return v;
+  }
+
   /// Append an event to the stream.
   append(key: K, event: V): void {
     const kb = key.encode();

package/std/assembly/toilscript.d.ts

@@ -250,10 +250,13 @@ declare class Documents<K, V> {
   /** Create-or-overwrite in one op (blind last-writer-wins); replaces the two-op
    *  `if (!create(k,v)) patch(k,v)` idiom. Right for writing a whole value; wrong
    *  for read-modify-write of accumulating state (a balance/count), where a
-   *  concurrent write would be lost - use `counter.add` or version-checked
-   *  `patch` there. The key is tenant-scoped, so a race is only ever the same
-   *  tenant's own writes. See {@link UpsertResult}. */
+   *  concurrent write would be lost - use `counter.add` or a caller-observed
+   *  conditional write there. The key is tenant-scoped, so a race is only ever
+   *  the same tenant's own writes. See {@link UpsertResult}. */
   upsert(key: K, value: V): UpsertResult;
+  /** Submit a replacement of an existing record; true when accepted, false on
+   *  absence or rejection. Does not compare against an earlier application read. */
+  enqueue(key: K, value: V): bool;
   delete(key: K): void;
   getDelete(key: K): V | null;
 }
@@ -275,6 +278,8 @@ declare class ClaimResult<V> {
 /** A globally-unique claim collection (spec 7.6): usernames, emails, slugs. */
 declare class Unique<K, V> {
   lookup(key: K): V | null;
+  /** Bounded owner lookup in input order; null for unclaimed keys. */
+  lookupMany(keys: K[]): Array<V | null>;
   claim(key: K, value: V): ClaimResult<V>;
   release(key: K, value: V): void;
 }
@@ -304,6 +309,11 @@ declare class Counter<K> {
 
 /** An append-only event log (spec 7.5): activity feeds, audit trails. */
 declare class Events<K, V> {
+  /** Read an event by its appendOnce eventId, or null if absent. */
+  get(key: K, eventId: string): V | null;
+  /** Read the newest appended event, or null for an empty stream. */
+  last(key: K): V | null;
+  appendOnce(key: K, eventId: string, event: V): bool;
   append(key: K, event: V): void;
   latest(key: K, limit: i32): V[];
   since(key: K, limit: i32): V[];