toiljs 0.0.60 → 0.0.61

package/src/devserver/db/catalog.ts

@@ -1,90 +1,80 @@
 /**
- * Parse a compiled server wasm's `toildb.catalog` custom section into a map of
- * `"<Db>/<collection>"` (the resolve key the guest passes to
- * `data.resolve_collection`) -> the collection's CURRENT `schema_version`.
+ * Parse a compiled server wasm's `toildb.catalog` custom section into structured
+ * dev capability metadata keyed by `"<Db>/<collection>"` (the resolve key the
+ * guest passes to `data.resolve_collection`).
  *
  * The dev DB uses this to STAMP each write with the value type's current schema
  * version. When the developer evolves a `@data` type and rebuilds, the catalog
  * version changes; data already on disk keeps its OLD stamp, so a read surfaces
  * that old version and the guest's woven `decodeInto` runs the `@migrate` - the
  * dev-side equivalent of the edge binding the cap's schema_version into the row.
+ * The parsed family is also used to reject wrong-family imports locally.
  *
  * Wire format mirrors `toildb::catalog` / the backend `db_catalog` decoder and the
  * compiler's `buildToilDbCatalog` emitter (all little-endian).
  */
 
-/** Read a LEB128 from `buf` at `pos`; throws on overrun (the section is a
- *  tenant-built, possibly mid-rebuild wasm, so it must never over-read). */
 import { DataReader } from 'toiljs/io';
+import { customSection } from '../wasm/sections.js';
+import {
+    CollectionFamily,
+    type DbCatalogState,
+    DEFAULT_FILL_WAIT_MS,
+    type DevCollectionHandle,
+    isCollectionFamily,
+    MAX_FILL_WAIT_MS,
+} from './types.js';
 
-function leb(buf: Buffer, pos: number): [number, number] {
-    let result = 0;
-    let shift = 0;
-    let p = pos;
-    for (;;) {
-        if (p >= buf.length) throw new RangeError('leb128 past end of buffer');
-        const b = buf[p++];
-        result |= (b & 0x7f) << shift;
-        if ((b & 0x80) === 0) break;
-        shift += 7;
-        if (shift > 35) throw new RangeError('leb128 too long');
-    }
-    return [result >>> 0, p];
+function validReplication(value: number): boolean {
+    return value >= 0 && value <= 5;
 }
 
-/** The bytes of the named wasm custom section, or null if absent. Bounds-checked
- *  so a truncated/garbage module can never read past the buffer. */
-function customSection(wasm: Buffer, want: string): Buffer | null {
-    let pos = 8; // skip the 8-byte magic + version header
-    while (pos < wasm.length) {
-        const id = wasm[pos++];
-        let size: number;
-        [size, pos] = leb(wasm, pos);
-        const end = pos + size;
-        if (end > wasm.length || end < pos) return null; // truncated section table
-        if (id === 0) {
-            let nameLen: number;
-            let namePos: number;
-            [nameLen, namePos] = leb(wasm, pos);
-            if (namePos + nameLen <= end && wasm.toString('latin1', namePos, namePos + nameLen) === want)
-                return wasm.subarray(namePos + nameLen, end);
-        }
-        pos = end;
-    }
-    return null;
+function validPlacement(value: number): boolean {
+    return value === 0 || value === 1;
 }
 
-/** `"<Db>/<collection>"` -> current `schema_version` for every collection. Decoded
- *  with the shared bounds-checked {@link DataReader} (it returns 0/empty + flips
- *  `.ok` past the end), so a truncated/garbage section - e.g. a mid-rebuild wasm -
- *  yields only the collections that decoded cleanly and never over-reads. Mirrors
- *  the compiler's `buildToilDbCatalog` emitter + the backend `db_catalog` decoder. */
-export function parseCatalog(wasm: Buffer): Map<string, number> {
-    const out = new Map<string, number>();
+/** Decode the devserver's catalog state. A missing section stays distinct from a
+ *  present-but-bad section so `resolve_collection` can match the edge's
+ *  Present/Malformed/NoSection admission behavior. */
+export function parseCatalog(wasm: Buffer): DbCatalogState {
+    const collections = new Map<string, DevCollectionHandle>();
     let sec: Buffer | null;
     try {
         sec = customSection(wasm, 'toildb.catalog');
     } catch {
-        return out; // garbage section table (mid-rebuild) -> no catalog
+        return { kind: 'no-section' }; // garbage section table (mid-rebuild) -> no catalog
     }
-    if (sec === null) return out;
+    if (sec === null) return { kind: 'no-section' };
 
     const r = new DataReader(sec);
-    r.readU16(); // catalog format version
+    const version = r.readU16();
+    if (!r.ok || (version !== 1 && version !== 2)) return { kind: 'malformed' };
     const ndb = r.readU16();
     for (let d = 0; d < ndb && r.ok; d++) {
         const db = r.readString();
         const nc = r.readU16();
         for (let c = 0; c < nc && r.ok; c++) {
             const name = r.readString();
-            r.readU8(); // family
+            const family = r.readU8();
             r.readString(); // keyType
             r.readString(); // valueType
             r.readU32(); // valueDataId
             const schemaVersion = r.readU32();
             r.readU32(); // generation
-            r.readU8(); // replication (emitter order: replication then placement)
-            r.readU8(); // placement
+            const replication = r.readU8(); // emitter order: replication then placement
+            const placement = r.readU8();
+            let fillMaxWaitMs = DEFAULT_FILL_WAIT_MS;
+            let fillAllowStale = true;
+            if (version >= 2) {
+                fillMaxWaitMs = r.readU32();
+                const fillAllowStaleByte = r.readU8();
+                if (
+                    fillMaxWaitMs > MAX_FILL_WAIT_MS ||
+                    (fillAllowStaleByte !== 0 && fillAllowStaleByte !== 1)
+                )
+                    return { kind: 'malformed' };
+                fillAllowStale = fillAllowStaleByte === 1;
+            }
             const nFields = r.readU16();
             for (let f = 0; f < nFields; f++) {
                 r.readString(); // field name
@@ -93,8 +83,26 @@ export function parseCatalog(wasm: Buffer): Map<string, number> {
             }
             const nMig = r.readU16();
             for (let m = 0; m < nMig; m++) r.readU32(); // migratableFrom versions
-            if (r.ok) out.set(db + '/' + name, schemaVersion >>> 0);
+            if (
+                !isCollectionFamily(family) ||
+                !validReplication(replication) ||
+                !validPlacement(placement)
+            )
+                return { kind: 'malformed' };
+            const key = db + '/' + name;
+            if (collections.has(key)) return { kind: 'malformed' };
+            if (r.ok)
+                collections.set(key, {
+                    name: key,
+                    family: family as CollectionFamily,
+                    schemaVersion: schemaVersion >>> 0,
+                    replication,
+                    placement,
+                    fillMaxWaitMs,
+                    fillAllowStale,
+                });
         }
     }
-    return out;
+    if (!r.ok || r.remaining() !== 0) return { kind: 'malformed' };
+    return { kind: 'present', collections };
 }