toiljs 0.0.69 → 0.0.70

package/test/rpc-dispatch.test.ts

@@ -0,0 +1,132 @@
+/**
+ * @service / @remote RPC: a real round trip into the example project's toilscript-compiled server
+ * wasm. A `POST /__toil_rpc` carrying the FNV method id in the `toil-rpc` header is dispatched by the
+ * runtime `Rpc` registry (compiler-injected `__rpcDispatch` + `Rpc.register`) to the @remote method,
+ * and the @data/scalar result comes back encoded with the same DataWriter codec the client decodes.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import { WasmServerModule } from '../src/devserver/index.js';
+
+const EXAMPLE_WASM = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    '../examples/basic/build/server/release.wasm',
+);
+
+/** FNV-1a (the toilscript `dataTypeId`); the client + the parser injection must agree on this. */
+function fnv1a(s: string): number {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 0x01000193) >>> 0;
+    return h >>> 0;
+}
+
+describe.skipIf(!fs.existsSync(EXAMPLE_WASM))('@service RPC dispatch', () => {
+    const load = (): WasmServerModule => {
+        const m = new WasmServerModule(EXAMPLE_WASM);
+        m.refresh();
+        return m;
+    };
+
+    it('dispatches Server.stats.playerCount() over /__toil_rpc', () => {
+        const id = fnv1a('Stats.playerCount');
+        expect(id).toBe(118912982); // matches the generated __toilRpc client
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', String(id)]],
+            body: new Uint8Array(0),
+        });
+        expect(r.unhandled).toBe(false);
+        expect(r.status).toBe(200);
+        // The result is a DataWriter-encoded i32 (the seeded player count = 3).
+        expect(r.body.length).toBe(4);
+        const dv = new DataView(r.body.buffer, r.body.byteOffset, r.body.length);
+        expect(dv.getInt32(0, true)).toBe(3);
+    });
+
+    it('dispatches a free Server.ping(n) over /__toil_rpc', () => {
+        const id = fnv1a('ping');
+        const body = new Uint8Array(4);
+        new DataView(body.buffer).setInt32(0, 41, true); // arg n = 41 (DataWriter writeI32, LE)
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', String(id)]],
+            body,
+        });
+        expect(r.status).toBe(200);
+        expect(r.body.length).toBe(4);
+        const dv = new DataView(r.body.buffer, r.body.byteOffset, r.body.length);
+        expect(dv.getInt32(0, true)).toBe(42); // ping(41) = 42
+    });
+
+    it('round-trips a Uint8Array[] arg + result (writeBytes/readBytes loop, the #5 fix)', () => {
+        const id = fnv1a('echoParts');
+        const parts = [Uint8Array.from([1, 2]), Uint8Array.from([3, 4, 5])];
+        const buf: number[] = [];
+        const pushU32 = (v: number) => buf.push(v & 255, (v >> 8) & 255, (v >> 16) & 255, (v >>> 24) & 255);
+        pushU32(parts.length); // u32 count, then per part: u32 len + bytes (DataWriter.writeBytes)
+        for (const p of parts) {
+            pushU32(p.length);
+            for (const b of p) buf.push(b);
+        }
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', String(id)]],
+            body: Uint8Array.from(buf),
+        });
+        expect(r.status).toBe(200);
+        const dv = new DataView(r.body.buffer, r.body.byteOffset, r.body.length);
+        let off = 0;
+        const count = dv.getUint32(off, true);
+        off += 4;
+        const out: number[][] = [];
+        for (let i = 0; i < count; i++) {
+            const len = dv.getUint32(off, true);
+            off += 4;
+            out.push([...r.body.subarray(off, off + len)]);
+            off += len;
+        }
+        expect(out).toEqual([
+            [1, 2],
+            [3, 4, 5],
+        ]);
+    });
+
+    it('rejects an @auth @remote with 401 when there is no session', () => {
+        const id = fnv1a('Stats.secretCount');
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', String(id)]],
+            body: new Uint8Array(0),
+        });
+        expect(r.status).toBe(401);
+    });
+
+    it('returns 400 for an unknown method id', () => {
+        const r = load().dispatch({
+            method: 'POST',
+            path: '/__toil_rpc',
+            headers: [['toil-rpc', '999999']],
+            body: new Uint8Array(0),
+        });
+        expect(r.status).toBe(400);
+    });
+
+    it('does not intercept a non-RPC request (no toil-rpc header)', () => {
+        const r = load().dispatch({
+            method: 'GET',
+            path: '/json',
+            headers: [['host', 'localhost:3000']],
+            body: new Uint8Array(0),
+        });
+        expect(r.status).toBe(200);
+        expect(Buffer.from(r.body).toString()).toBe('{"hello":"toiljs"}\n');
+    });
+});

package/test/rpc-kinds.test.ts

@@ -0,0 +1,18 @@
+/**
+ * The dev-server RPC DB-kind resolution (audit #2): an `@action` @remote may write; a plain/read-only
+ * @remote (absent from `toildb.rpc_kinds`) defaults to read-only Query, matching the edge host gate.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { rpcKindForId, type RpcKindEntry } from '../src/devserver/db/routeKinds.js';
+import { DbFunctionKind } from '../src/devserver/db/types.js';
+
+describe('rpcKindForId', () => {
+    it('returns the @action kind for a listed id, and read-only Query for an absent one', () => {
+        const methods: RpcKindEntry[] = [{ methodId: 42, kind: DbFunctionKind.Action }];
+        expect(rpcKindForId(methods, 42)).toBe(DbFunctionKind.Action);
+        // An id NOT in rpc_kinds (a plain/read-only @remote) defaults to Query - the safe default.
+        expect(rpcKindForId(methods, 999)).toBe(DbFunctionKind.Query);
+        expect(rpcKindForId([], 42)).toBe(DbFunctionKind.Query);
+    });
+});

package/test/rpc.test.ts

@@ -2,9 +2,14 @@ import { afterEach, describe, expect, it } from 'vitest';
 
 import { Server } from '../src/client/rpc';
 
-// `Server` is the runtime behind the generated typed surface. Until the transport
-// is wired, it is a recursive proxy that throws on call.
-describe('Server RPC stub', () => {
+// `Server` is the runtime behind the generated typed surface. The RPC branch surfaces
+// `globalThis.__toilRpc` (attached by the generated `shared/server.ts`); when that client has
+// not loaded, the proxy throws a helpful "client has not loaded" error naming the path.
+describe('Server RPC stub (client not loaded)', () => {
+    afterEach(() => {
+        delete (globalThis as { __toilRpc?: unknown }).__toilRpc;
+    });
+
     it('throws on a direct call, naming the path', () => {
         const s = Server as { ping: () => unknown };
         expect(() => s.ping()).toThrow(/Server\.ping\(\)/);
@@ -13,7 +18,18 @@ describe('Server RPC stub', () => {
     it('throws on a nested service.method call', () => {
         const s = Server as { accounts: { getUser: () => unknown } };
         expect(() => s.accounts.getUser()).toThrow(/Server\.accounts\.getUser\(\)/);
-        expect(() => s.accounts.getUser()).toThrow(/not available yet/);
+        expect(() => s.accounts.getUser()).toThrow(/has not loaded/);
+    });
+
+    it('surfaces the attached RPC client (service method + free remote) once loaded', async () => {
+        const fake = { stats: { playerCount: async () => 3 }, ping: async (n: number) => n + 1 };
+        (globalThis as { __toilRpc?: unknown }).__toilRpc = fake;
+        const s = Server as {
+            stats: { playerCount: () => Promise<number> };
+            ping: (n: number) => Promise<number>;
+        };
+        expect(await s.stats.playerCount()).toBe(3);
+        expect(await s.ping(41)).toBe(42);
     });
 
     it('is not thenable (so it is not mistaken for a promise)', () => {

package/build/devserver/mstore/store.d.ts

@@ -1,18 +0,0 @@
-export declare class DevMemoryStore {
-    private readonly map;
-    private now;
-    private live;
-    private exp;
-    get(key: string): Buffer | null;
-    set(key: string, value: Buffer, ttlSecs: number): void;
-    delete(key: string): boolean;
-    incr(key: string, delta: bigint, ttlSecs: number): bigint | null;
-    cas(key: string, expect: Buffer | null, next: Buffer, ttlSecs: number): boolean;
-    expire(key: string, ttlSecs: number): boolean;
-    scan(prefix: string, cursor: bigint): {
-        next: bigint;
-        keys: string[];
-    } | null;
-    __reset(): void;
-}
-export declare const devMemoryStore: DevMemoryStore;

package/build/devserver/mstore/store.js

@@ -1,82 +0,0 @@
-export class DevMemoryStore {
-    map = new Map();
-    now() {
-        return Date.now();
-    }
-    live(key) {
-        const e = this.map.get(key);
-        if (e === undefined)
-            return null;
-        if (e.expiresAtMs !== 0 && e.expiresAtMs <= this.now()) {
-            this.map.delete(key);
-            return null;
-        }
-        return e;
-    }
-    exp(ttlSecs) {
-        return ttlSecs > 0 ? this.now() + ttlSecs * 1000 : 0;
-    }
-    get(key) {
-        const e = this.live(key);
-        return e ? e.value : null;
-    }
-    set(key, value, ttlSecs) {
-        this.map.set(key, { value: Buffer.from(value), expiresAtMs: this.exp(ttlSecs) });
-    }
-    delete(key) {
-        return this.map.delete(key);
-    }
-    incr(key, delta, ttlSecs) {
-        const e = this.live(key);
-        let cur = 0n;
-        if (e !== null) {
-            const s = e.value.toString('utf8').trim();
-            if (!/^-?\d+$/.test(s))
-                return null;
-            try {
-                cur = BigInt(s);
-            }
-            catch {
-                return null;
-            }
-        }
-        const next = BigInt.asIntN(64, cur + delta);
-        this.map.set(key, {
-            value: Buffer.from(next.toString(), 'utf8'),
-            expiresAtMs: ttlSecs > 0 ? this.exp(ttlSecs) : (e?.expiresAtMs ?? 0),
-        });
-        return next;
-    }
-    cas(key, expect, next, ttlSecs) {
-        const e = this.live(key);
-        if (expect === null) {
-            if (e !== null)
-                return false;
-        }
-        else if (e === null || !e.value.equals(expect)) {
-            return false;
-        }
-        this.map.set(key, { value: Buffer.from(next), expiresAtMs: this.exp(ttlSecs) });
-        return true;
-    }
-    expire(key, ttlSecs) {
-        const e = this.live(key);
-        if (!e)
-            return false;
-        e.expiresAtMs = this.exp(ttlSecs);
-        return true;
-    }
-    scan(prefix, cursor) {
-        const live = [...this.map.keys()].filter((k) => this.live(k) !== null && k.startsWith(prefix));
-        live.sort();
-        const start = Number(cursor);
-        if (start < 0 || start > live.length)
-            return null;
-        const batch = live.slice(start);
-        return { next: BigInt(live.length), keys: batch };
-    }
-    __reset() {
-        this.map.clear();
-    }
-}
-export const devMemoryStore = new DevMemoryStore();

package/src/devserver/mstore/store.ts

@@ -1,121 +0,0 @@
-/**
- * Dev MemoryStore: a single in-memory `Map` with per-entry TTL, one per process,
- * persisted nowhere (ephemeral by definition). Backs the `mstore.*` host imports
- * (RECONCILIATION Part 4, F2: HANDLELESS, ttl in SECONDS, inline drain). Keys are
- * auto-scoped to host+region; the dev process is one host/region, so the key is
- * used verbatim. Shared by streams (Phase 4) AND the daemon (both reference the
- * same `devMemoryStore` singleton), matching doc 06's "shared across
- * streams/handlers on the same region".
- *
- * TTL is enforced LAZILY on read (no background sweep), mirroring the dev DB's
- * no-background-thread design. The error space is RECONCILIATION Part 3's 0x03xx
- * registry; the host-import layer (daemon/host.ts) maps these results onto the
- * Part 3 negative-return bridge.
- */
-
-interface MStoreEntry {
-    value: Buffer;
-    /** `0` means no TTL; otherwise the epoch-ms the entry expires at. */
-    expiresAtMs: number;
-}
-
-export class DevMemoryStore {
-    private readonly map = new Map<string, MStoreEntry>();
-
-    private now(): number {
-        return Date.now();
-    }
-
-    /** The live entry for `key`, collecting it lazily if its TTL has passed. */
-    private live(key: string): MStoreEntry | null {
-        const e = this.map.get(key);
-        if (e === undefined) return null;
-        if (e.expiresAtMs !== 0 && e.expiresAtMs <= this.now()) {
-            this.map.delete(key);
-            return null;
-        }
-        return e;
-    }
-
-    private exp(ttlSecs: number): number {
-        return ttlSecs > 0 ? this.now() + ttlSecs * 1000 : 0;
-    }
-
-    /** The value, or `null` (=> 0x0301 MSTORE_NOT_FOUND). */
-    get(key: string): Buffer | null {
-        const e = this.live(key);
-        return e ? e.value : null;
-    }
-
-    set(key: string, value: Buffer, ttlSecs: number): void {
-        this.map.set(key, { value: Buffer.from(value), expiresAtMs: this.exp(ttlSecs) });
-    }
-
-    delete(key: string): boolean {
-        return this.map.delete(key);
-    }
-
-    /** Add `delta` to the i64 stored at `key`; `null` => 0x0306 MSTORE_NOT_A_NUMBER. */
-    incr(key: string, delta: bigint, ttlSecs: number): bigint | null {
-        const e = this.live(key);
-        let cur = 0n;
-        if (e !== null) {
-            const s = e.value.toString('utf8').trim();
-            if (!/^-?\d+$/.test(s)) return null;
-            try {
-                cur = BigInt(s);
-            } catch {
-                return null;
-            }
-        }
-        const next = BigInt.asIntN(64, cur + delta);
-        this.map.set(key, {
-            value: Buffer.from(next.toString(), 'utf8'),
-            // An incr on an existing key keeps its TTL unless a new one is given.
-            expiresAtMs: ttlSecs > 0 ? this.exp(ttlSecs) : (e?.expiresAtMs ?? 0),
-        });
-        return next;
-    }
-
-    /** `expect === null` means expect-absent (the dev mapping of `expect_len == 0`).
-     *  Returns `false` => 0x0304 MSTORE_CONFLICT. */
-    cas(key: string, expect: Buffer | null, next: Buffer, ttlSecs: number): boolean {
-        const e = this.live(key);
-        if (expect === null) {
-            if (e !== null) return false; // expect-absent, but present
-        } else if (e === null || !e.value.equals(expect)) {
-            return false; // expect-match failed
-        }
-        this.map.set(key, { value: Buffer.from(next), expiresAtMs: this.exp(ttlSecs) });
-        return true;
-    }
-
-    /** Re-arm the TTL of a live key; `false` => key absent (0x0301). */
-    expire(key: string, ttlSecs: number): boolean {
-        const e = this.live(key);
-        if (!e) return false;
-        e.expiresAtMs = this.exp(ttlSecs);
-        return true;
-    }
-
-    /**
-     * Prefix walk. `cursor` is an opaque resume index; a stale cursor (one that
-     * points past the current live key set after deletions) returns `null`
-     * (=> 0x0307 MSTORE_SCAN_BUSY). Returns the next cursor + the matched keys.
-     */
-    scan(prefix: string, cursor: bigint): { next: bigint; keys: string[] } | null {
-        const live = [...this.map.keys()].filter((k) => this.live(k) !== null && k.startsWith(prefix));
-        live.sort();
-        const start = Number(cursor);
-        if (start < 0 || start > live.length) return null; // stale cursor
-        const batch = live.slice(start);
-        return { next: BigInt(live.length), keys: batch };
-    }
-
-    /** Test-only: drop all entries. */
-    __reset(): void {
-        this.map.clear();
-    }
-}
-
-export const devMemoryStore = new DevMemoryStore();