toiljs 0.0.53 → 0.0.55

package/build/devserver/database.js

@@ -0,0 +1,334 @@
+const STORE = new Map();
+const VIEWS = new Map();
+const MEMBERS = new Map();
+const COUNTERS = new Map();
+const EVENTS = new Map();
+const MAX_NAME = 512;
+const MAX_KEY = 4096;
+const MAX_VALUE = 256 * 1024;
+const I64_MIN = -(2n ** 63n);
+const I64_MAX = 2n ** 63n - 1n;
+function satI64(v) {
+    return v < I64_MIN ? I64_MIN : v > I64_MAX ? I64_MAX : v;
+}
+const ABSENT = -2;
+const TOO_SMALL = -1;
+const INVALID_HANDLE = -1001;
+const PRODUCT_ERR = -1000;
+export function freshDbState() {
+    return { handles: [], lastResult: null };
+}
+function mem(ref) {
+    if (!ref.memory)
+        throw new Error('data host import called before memory was bound');
+    return Buffer.from(ref.memory.buffer);
+}
+function readCopy(ref, ptr, len) {
+    const m = mem(ref);
+    if (ptr < 0 || len < 0 || ptr + len > m.length)
+        throw new Error(`data read out of bounds: ptr=${String(ptr)} len=${String(len)}`);
+    return Buffer.from(m.subarray(ptr, ptr + len));
+}
+function storeKey(collection, key) {
+    return collection + '\0' + key.toString('latin1');
+}
+function collOf(db, handle) {
+    return handle >= 0 && handle < db.handles.length ? db.handles[handle] : null;
+}
+export function buildDatabaseImports(ref, db) {
+    return {
+        'data.resolve_collection': (namePtr, nameLen, outHandlePtr) => {
+            if (nameLen < 0 || nameLen > MAX_NAME)
+                throw new Error('data: collection name too long');
+            const name = readCopy(ref, namePtr, nameLen).toString('utf8');
+            const handle = db.handles.length;
+            db.handles.push(name);
+            const m = mem(ref);
+            if (outHandlePtr < 0 || outHandlePtr + 4 > m.length)
+                throw new Error('data: resolve out-handle out of bounds');
+            m.writeUInt32LE(handle, outHandlePtr);
+            return 0;
+        },
+        'data.get': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY)
+                throw new Error('data: key too long');
+            const v = STORE.get(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            if (v === undefined)
+                return ABSENT;
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.get_many': (handle, keysPtr, keysLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keysLen > MAX_VALUE)
+                throw new Error('data: keys blob too large');
+            const blob = readCopy(ref, keysPtr, keysLen);
+            let off = 0;
+            const count = blob.readUInt32LE(off);
+            off += 4;
+            if (count > 1024)
+                return PRODUCT_ERR;
+            const header = Buffer.alloc(4);
+            header.writeUInt32LE(count, 0);
+            const parts = [header];
+            for (let i = 0; i < count; i++) {
+                const len = blob.readUInt32LE(off);
+                off += 4;
+                const key = blob.subarray(off, off + len);
+                off += len;
+                const v = STORE.get(storeKey(coll, key));
+                if (v === undefined) {
+                    parts.push(Buffer.from([0]));
+                }
+                else {
+                    const h = Buffer.alloc(5);
+                    h.writeUInt8(1, 0);
+                    h.writeUInt32LE(v.length, 1);
+                    parts.push(h, v);
+                }
+            }
+            db.lastResult = Buffer.concat(parts);
+            return db.lastResult.length;
+        },
+        'data.exists': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            return STORE.has(storeKey(coll, readCopy(ref, keyPtr, keyLen))) ? 1 : 0;
+        },
+        'data.create': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || valLen > MAX_VALUE)
+                throw new Error('data: key/value too large');
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            if (STORE.has(sk))
+                return PRODUCT_ERR;
+            STORE.set(sk, readCopy(ref, valPtr, valLen));
+            return 0;
+        },
+        'data.patch': (handle, keyPtr, keyLen, patchPtr, patchLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || patchLen > MAX_VALUE)
+                throw new Error('data: key/patch too large');
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            if (!STORE.has(sk))
+                return PRODUCT_ERR;
+            const v = readCopy(ref, patchPtr, patchLen);
+            STORE.set(sk, v);
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.delete': (handle, keyPtr, keyLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            STORE.delete(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            return 0;
+        },
+        'data.get_delete': (handle, keyPtr, keyLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            const v = STORE.get(sk);
+            if (v === undefined)
+                return ABSENT;
+            STORE.delete(sk);
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.unique_lookup': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const v = STORE.get(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            if (v === undefined)
+                return ABSENT;
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.unique_claim': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || valLen > MAX_VALUE)
+                throw new Error('data: key/value too large');
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            const owner = readCopy(ref, valPtr, valLen);
+            const existing = STORE.get(sk);
+            if (existing === undefined) {
+                STORE.set(sk, owner);
+                return 0;
+            }
+            if (existing.equals(owner))
+                return 2;
+            db.lastResult = existing;
+            return 1;
+        },
+        'data.unique_release': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            const existing = STORE.get(sk);
+            if (existing === undefined)
+                return 0;
+            if (!existing.equals(readCopy(ref, valPtr, valLen)))
+                return PRODUCT_ERR;
+            STORE.delete(sk);
+            return 0;
+        },
+        'data.membership_contains': (handle, setPtr, setLen, memberPtr, memberLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const set = MEMBERS.get(storeKey(coll, readCopy(ref, setPtr, setLen)));
+            if (set === undefined)
+                return 0;
+            return set.has(readCopy(ref, memberPtr, memberLen).toString('latin1')) ? 1 : 0;
+        },
+        'data.membership_add': (handle, setPtr, setLen, memberPtr, memberLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (setLen > MAX_KEY || memberLen > MAX_VALUE)
+                throw new Error('data: set/member too large');
+            const sk = storeKey(coll, readCopy(ref, setPtr, setLen));
+            const member = readCopy(ref, memberPtr, memberLen);
+            let set = MEMBERS.get(sk);
+            if (set === undefined) {
+                set = new Map();
+                MEMBERS.set(sk, set);
+            }
+            set.set(member.toString('latin1'), member);
+            return 0;
+        },
+        'data.membership_remove': (handle, setPtr, setLen, memberPtr, memberLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const set = MEMBERS.get(storeKey(coll, readCopy(ref, setPtr, setLen)));
+            if (set !== undefined)
+                set.delete(readCopy(ref, memberPtr, memberLen).toString('latin1'));
+            return 0;
+        },
+        'data.membership_list': (handle, setPtr, setLen, limit) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const set = MEMBERS.get(storeKey(coll, readCopy(ref, setPtr, setLen)));
+            const n = Math.max(0, Math.min(limit, 0xffff));
+            const members = set === undefined ? [] : Array.from(set.values()).sort(Buffer.compare).slice(0, n);
+            const header = Buffer.alloc(4);
+            header.writeUInt32LE(members.length, 0);
+            const parts = [header];
+            for (const m of members) {
+                const h = Buffer.alloc(4);
+                h.writeUInt32LE(m.length, 0);
+                parts.push(h, m);
+            }
+            db.lastResult = Buffer.concat(parts);
+            return db.lastResult.length;
+        },
+        'data.view_get': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const v = VIEWS.get(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            if (v === undefined)
+                return ABSENT;
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.view_publish': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || valLen > MAX_VALUE)
+                throw new Error('data: key/view too large');
+            VIEWS.set(storeKey(coll, readCopy(ref, keyPtr, keyLen)), readCopy(ref, valPtr, valLen));
+            return 0;
+        },
+        'data.counter_get': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const sum = COUNTERS.get(storeKey(coll, readCopy(ref, keyPtr, keyLen))) ?? 0n;
+            const out = Buffer.alloc(8);
+            out.writeBigInt64LE(sum);
+            db.lastResult = out;
+            return out.length;
+        },
+        'data.counter_add': (handle, keyPtr, keyLen, delta, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            COUNTERS.set(sk, satI64((COUNTERS.get(sk) ?? 0n) + BigInt(delta)));
+            return 0;
+        },
+        'data.append': (handle, keyPtr, keyLen, evPtr, evLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || evLen > MAX_VALUE)
+                throw new Error('data: key/event too large');
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            const log = EVENTS.get(sk);
+            const ev = readCopy(ref, evPtr, evLen);
+            if (log === undefined)
+                EVENTS.set(sk, [ev]);
+            else
+                log.push(ev);
+            return 0;
+        },
+        'data.latest': (handle, keyPtr, keyLen, limit) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const log = EVENTS.get(storeKey(coll, readCopy(ref, keyPtr, keyLen))) ?? [];
+            const n = Math.max(0, Math.min(limit, 0xffff));
+            const newest = log.slice(Math.max(0, log.length - n)).reverse();
+            let size = 4;
+            for (const ev of newest)
+                size += 4 + ev.length;
+            const out = Buffer.alloc(size);
+            let off = out.writeUInt32LE(newest.length, 0);
+            for (const ev of newest) {
+                off = out.writeUInt32LE(ev.length, off);
+                off += ev.copy(out, off);
+            }
+            db.lastResult = out;
+            return out.length;
+        },
+        'data.take_result': (outPtr, outCap) => {
+            const v = db.lastResult;
+            if (v === null)
+                return 0;
+            if (v.length > outCap)
+                return TOO_SMALL;
+            const m = mem(ref);
+            if (outPtr < 0 || outPtr + v.length > m.length)
+                throw new Error('data: take_result out of bounds');
+            v.copy(m, outPtr);
+            db.lastResult = null;
+            return v.length;
+        },
+    };
+}
+export function __resetDbForTests() {
+    STORE.clear();
+    VIEWS.clear();
+    MEMBERS.clear();
+    COUNTERS.clear();
+    EVENTS.clear();
+}

package/build/devserver/host.d.ts

@@ -1,4 +1,5 @@
 import { type CryptoState } from './crypto.js';
+import { type DbDevState } from './database.js';
 export declare class WasmAbortError extends Error {
     constructor(message: string, fileName: string, line: number, column: number);
 }
@@ -9,6 +10,7 @@ export interface DispatchState {
     sendfile: string | null;
     clientIp: string;
     crypto: CryptoState;
+    db: DbDevState;
 }
 export declare function freshDispatchState(): DispatchState;
 export interface MemoryRef {

package/build/devserver/host.js

@@ -1,5 +1,5 @@
 import { buildCryptoImports, freshCryptoState } from './crypto.js';
-import { buildKvImports } from './kv.js';
+import { buildDatabaseImports, freshDbState } from './database.js';
 import { EmailStatus, getEmailService } from './email/index.js';
 import { parseEmailBlob } from './email/wire.js';
 import { devEnvGet, devEnvGetSecure } from './env.js';
@@ -24,6 +24,7 @@ export function freshDispatchState() {
         sendfile: null,
         clientIp: '',
         crypto: freshCryptoState(),
+        db: freshDbState(),
     };
 }
 function mem(ref) {
@@ -141,7 +142,7 @@ export function buildHostImports(ref, state) {
             thread_spawn: (_startArg) => -1,
             'Date.now': () => Date.now(),
             ...buildCryptoImports(ref, state.crypto),
-            ...buildKvImports(ref),
+            ...buildDatabaseImports(ref, state.db),
         },
     };
 }

package/build/devserver/module.js

@@ -11,7 +11,13 @@ const PROVIDED_IMPORTS = new Set([
     'crypto.import_key', 'crypto.export_key', 'crypto.encrypt', 'crypto.decrypt',
     'crypto.sign', 'crypto.verify', 'crypto.derive_bits',
     'crypto.mldsa_verify', 'crypto.mlkem_decapsulate', 'crypto.voprf_evaluate',
-    'kv.put', 'kv.get', 'kv.getdel',
+    'data.resolve_collection', 'data.get', 'data.get_many', 'data.exists', 'data.create',
+    'data.patch', 'data.delete', 'data.get_delete',
+    'data.unique_lookup', 'data.unique_claim', 'data.unique_release',
+    'data.view_get', 'data.view_publish',
+    'data.membership_contains', 'data.membership_add', 'data.membership_remove', 'data.membership_list',
+    'data.counter_get', 'data.counter_add', 'data.append', 'data.latest',
+    'data.take_result',
 ]);
 export class WasmServerModule {
     wasmPath;

package/examples/basic/client/routes/rest.tsx

@@ -6,12 +6,20 @@
 // `Response` to inspect (status, `.json()`, ...). Needs the server running to respond.
 import { useState } from 'react';
 
-import { NewPlayer, ScoreDelta } from 'shared/server';
+import { NewMessage, NewPlayer, ScoreDelta } from 'shared/server';
 
 export default function RestDemo() {
     const [log, setLog] = useState<string[]>([]);
     const note = (line: string) => setLog((prev) => [line, ...prev].slice(0, 8));
 
+    // The guestbook is backed by ToilDB (an `events` stream + a `counter`), so unlike
+    // the players below its data PERSISTS across requests. Sign a few times, reload the
+    // page, and the total is still there.
+    const [book, setBook] = useState<{ total: bigint; entries: { author: string; message: string }[] }>({
+        total: 0n,
+        entries: [],
+    });
+
     // POST /players  ->  typed Promise<Player>, body is a @data class. The server returns the
     // new player, but it is NOT saved (server memory resets per request); this is a preview.
     const onCreate = async () => {
@@ -67,6 +75,31 @@ export default function RestDemo() {
         }
     };
 
+    // POST /guestbook  ->  typed Promise<GuestbookView>. This one is PERSISTED in ToilDB
+    // (events + counter), so the total keeps climbing across requests and reloads.
+    const signers = ['Ada', 'Linus', 'Grace', 'Ken'];
+    const onSign = async () => {
+        try {
+            const author = signers[Math.floor(Math.random() * signers.length)];
+            const v = await Server.REST.guestbook.sign({ body: new NewMessage(author, 'was here') });
+            setBook(v);
+            note(`${author} signed -> ${v.total} signatures (persisted in ToilDB)`);
+        } catch (err) {
+            note(parseError(err));
+        }
+    };
+
+    // GET /guestbook  ->  the running total + the newest entries.
+    const onBook = async () => {
+        try {
+            const v = await Server.REST.guestbook.list();
+            setBook(v);
+            note(`guestbook: ${v.total} signatures`);
+        } catch (err) {
+            note(parseError(err));
+        }
+    };
+
     return (
         <main>
             <h1>REST</h1>
@@ -83,6 +116,24 @@ export default function RestDemo() {
                     <li key={i}>{line}</li>
                 ))}
             </ul>
+
+            <h2>Guestbook (persisted via ToilDB)</h2>
+            <p>
+                The same <code>Server.REST.*</code> client, but the route stores each signature in a ToilDB{' '}
+                <code>events</code> stream and a <code>counter</code>. So unlike the players above, these{' '}
+                <strong>persist</strong> across requests and page reloads - locally under <code>toil dev</code> and on
+                ScyllaDB at the edge, with the same code.
+            </p>
+            <button onClick={onSign}>sign the guestbook</button>{' '}
+            <button onClick={onBook}>refresh ({String(book.total)} signatures)</button>
+            <ul>
+                {book.entries.map((e, i) => (
+                    <li key={i}>
+                        <strong>{e.author}</strong>: {e.message}
+                    </li>
+                ))}
+            </ul>
+
             <Toil.Link href="/">Back home</Toil.Link>
         </main>
     );

package/examples/basic/server/core/AppHandler.ts

@@ -7,24 +7,6 @@ import { Method, Request, Response, Rest, ToilHandler } from 'toiljs/server/runt
  */
 export class AppHandler extends ToilHandler {
     public handle(req: Request): Response {
-        // Session signing secret: set on EVERY request, BEFORE routing. The signed
-        // session cookie is minted in one route (auth login / session dev-login) but
-        // verified by the `@auth` gate in another, and each request runs in a FRESH
-        // wasm instance -- so a secret configured inside a single handler is absent on
-        // the instance that verifies `/session/me`, and the HMAC check fails (401).
-        // Setting it here, at the one entry point every request passes through, makes
-        // mint and verify always agree. Read from the env store with a clearly-insecure
-        // DEV fallback so the demo runs with zero config; set AUTH_SESSION_SECRET in
-        // `.env.secrets` for any non-throwaway use.
-        const sessionSecret = Environment.getSecure('AUTH_SESSION_SECRET');
-        AuthService.setSecret(
-            Uint8Array.wrap(
-                String.UTF8.encode(
-                    sessionSecret != null ? sessionSecret : 'toil-demo-insecure-session-secret-change-me',
-                ),
-            ),
-        );
-
         // Rest.dispatch returns the first matching route's Response, or null if nothing
         // matched - then we fall through to our own logic. REST composes; it never takes
         // over handle().

package/examples/basic/server/main.ts

@@ -9,6 +9,7 @@ import { AppHandler } from './core/AppHandler';
 import './routes/Auth';
 import './routes/Players';
 import './routes/Leaderboard';
+import './routes/Guestbook';
 import './routes/Session';
 import './routes/EnvDemo';
 import './services/Stats';

package/examples/basic/server/models/GuestEntry.ts

@@ -0,0 +1,12 @@
+/** One signed guestbook entry, stored as a ToilDB `events` record. */
+@data
+export class GuestEntry {
+    author: string = '';
+    message: string = '';
+    at: u64 = 0;
+    constructor(author: string = '', message: string = '', at: u64 = 0) {
+        this.author = author;
+        this.message = message;
+        this.at = at;
+    }
+}

package/examples/basic/server/models/GuestbookView.ts

@@ -0,0 +1,10 @@
+import { GuestEntry } from './GuestEntry';
+
+/** The guestbook snapshot returned by the routes: the running signature count
+ *  plus the most-recent entries (newest first). A `@data` wrapper so the
+ *  `GuestEntry[]` round-trips through the codec. */
+@data
+export class GuestbookView {
+    total: i64 = 0;
+    entries: GuestEntry[] = [];
+}

package/examples/basic/server/models/NewMessage.ts

@@ -0,0 +1,6 @@
+/** Request body for `POST /guestbook` - a new signature to append. */
+@data
+export class NewMessage {
+    author: string = '';
+    message: string = '';
+}