toiljs 0.0.63 → 0.0.65

package/src/devserver/db/catalog.ts

@@ -26,7 +26,7 @@ import {
 } from './types.js';
 
 function validReplication(value: number): boolean {
-    return value >= 0 && value <= 5;
+    return value === 0 || value === 1 || value === 2 || value === 5;
 }
 
 function validPlacement(value: number): boolean {

package/src/devserver/runtime/module.ts

@@ -51,6 +51,15 @@ function dbKindForHttpMethod(method: string): DbFunctionKind {
     }
 }
 
+export function dbFunctionKindForRequest(
+    routes: readonly RouteKindEntry[],
+    method: string,
+    path: string,
+): DbFunctionKind {
+    const routeKind = routeKindForRequest(routes, method, path);
+    return routeKind === DbFunctionKind.Query ? DbFunctionKind.Query : dbKindForHttpMethod(method);
+}
+
 /** The shaped outcome of one guest dispatch. */
 export interface WasmDispatchResult {
     readonly status: number;
@@ -186,20 +195,9 @@ export class WasmServerModule {
         const ref: MemoryRef = { memory: null };
         const state = freshDispatchState();
         state.clientIp = req.clientIp ?? '';
-        // Enforce per-route DB-kind gating ONLY when the guest declares its route
-        // kinds (the `toildb.route_kinds` custom section). A guest built with a
-        // toolchain that does not emit that section leaves `routeKinds` empty;
-        // inferring a kind from the HTTP method and enforcing it would wrongly
-        // reject legitimate bounded reads (e.g. a GET that reads `events.latest`,
-        // a scan-class op denied in `Query`). With no declarations we keep the
-        // unenforced default (`Job`, see `freshDbState`).
-        const routeKind = routeKindForRequest(this.routeKinds, req.method, req.path);
-        state.db.functionKind =
-            this.routeKinds.length === 0
-                ? DbFunctionKind.Job
-                : routeKind === DbFunctionKind.Query
-                  ? DbFunctionKind.Query
-                  : dbKindForHttpMethod(req.method);
+        // Match the edge DB gate: the HTTP method is the baseline authority,
+        // and `toildb.route_kinds` can only tighten a mutating route to query.
+        state.db.functionKind = dbFunctionKindForRequest(this.routeKinds, req.method, req.path);
         const instance = new WebAssembly.Instance(this.module, buildHostImports(ref, state));
         const exports = instance.exports as unknown as HandleExports;
         ref.memory = exports.memory;

package/test/devserver-database.test.ts

@@ -16,6 +16,7 @@ import {
     setDbCatalog,
 } from '../src/devserver/db/index.js';
 import { parseRouteKinds, routeKindForRequest } from '../src/devserver/db/routeKinds.js';
+import { dbFunctionKindForRequest } from '../src/devserver/runtime/module.js';
 import type { MemoryRef } from '../src/devserver/runtime/host.js';
 
 const DEFAULT_CATALOG = {
@@ -91,7 +92,7 @@ function routeKindsSection(routes: readonly (readonly [number, number, string])[
     return Buffer.concat(chunks);
 }
 
-function catalogSectionV2(fillMaxWaitMs: number, fillAllowStale: number): Buffer {
+function catalogSectionV2(fillMaxWaitMs: number, fillAllowStale: number, replication = 5): Buffer {
     const chunks: Buffer[] = [];
     const u8 = (v: number) => chunks.push(Buffer.from([v & 0xff]));
     const u16 = (v: number) => {
@@ -121,7 +122,7 @@ function catalogSectionV2(fillMaxWaitMs: number, fillAllowStale: number): Buffer
     u32(0xaaaa);
     u32(0x1234);
     u32(0); // generation
-    u8(5); // replication = localOnly, accepted by the backend ABI
+    u8(replication); // replication
     u8(0); // placement = hashKey
     u32(fillMaxWaitMs);
     u8(fillAllowStale);
@@ -151,6 +152,31 @@ describe('toildb dev emulator (record family)', () => {
         expect(routeKindForRequest(routes, 'POST', '/api/items')).toBeNull();
     });
 
+    it('matches the edge method clamp when route-kind metadata is absent', () => {
+        expect(dbFunctionKindForRequest([], 'GET', '/api/users')).toBe(DbFunctionKind.Query);
+        expect(dbFunctionKindForRequest([], 'HEAD', '/api/users')).toBe(DbFunctionKind.Query);
+        expect(dbFunctionKindForRequest([], 'OPTIONS', '/api/users')).toBe(DbFunctionKind.Query);
+        expect(dbFunctionKindForRequest([], 'POST', '/api/users')).toBe(DbFunctionKind.Action);
+        expect(dbFunctionKindForRequest([], 'PUT', '/api/users')).toBe(DbFunctionKind.Action);
+        expect(dbFunctionKindForRequest([], 'PATCH', '/api/users')).toBe(DbFunctionKind.Action);
+        expect(dbFunctionKindForRequest([], 'DELETE', '/api/users')).toBe(DbFunctionKind.Action);
+    });
+
+    it('uses route-kind metadata only to tighten mutating routes to query', () => {
+        const wasm = wasmWithSection(
+            'toildb.route_kinds',
+            routeKindsSection([
+                [1, 0, '/api/search'],
+                [0, 1, '/api/users'],
+            ]),
+        );
+        const routes = parseRouteKinds(wasm);
+
+        expect(dbFunctionKindForRequest(routes, 'POST', '/api/search')).toBe(DbFunctionKind.Query);
+        expect(dbFunctionKindForRequest(routes, 'POST', '/api/write')).toBe(DbFunctionKind.Action);
+        expect(dbFunctionKindForRequest(routes, 'GET', '/api/users')).toBe(DbFunctionKind.Query);
+    });
+
     it('ignores malformed route-kind metadata like the edge method clamp fallback', () => {
         expect(
             parseRouteKinds(wasmWithSection('toildb.route_kinds', Buffer.from([1, 0, 1, 0, 1]))),
@@ -205,6 +231,16 @@ describe('toildb dev emulator (record family)', () => {
         });
     });
 
+    it('rejects replication policies that require catalog v3 metadata', () => {
+        for (const replication of [3, 4]) {
+            setDbCatalog(wasmWithSection('toildb.catalog', catalogSectionV2(7, 0, replication)));
+            const { imports, buf } = setupRaw();
+            const [p, l] = put(buf, 0, 'App/users');
+
+            expect(imports['data.resolve_collection'](p, l, 16)).toBe(-1070);
+        }
+    });
+
     it('rejects malformed catalog v2 fill policy', () => {
         setDbCatalog(wasmWithSection('toildb.catalog', catalogSectionV2(7, 2)));
         const { imports, buf } = setupRaw();