toiljs 0.0.60 → 0.0.62

package/build/devserver/db/index.d.ts

@@ -1,3 +1,3 @@
 export { __resetDbForTests, __setDbCatalogForTests, buildDatabaseImports, configureDbPersistence, DevDatabase, devDb, persistDb, setDbCatalog, } from './database.js';
 export { parseCatalog } from './catalog.js';
-export { type DbDevState, freshDbState } from './types.js';
+export { CollectionFamily, DbFunctionKind, type DbDevState, freshDbState } from './types.js';

package/build/devserver/db/index.js

@@ -1,3 +1,3 @@
 export { __resetDbForTests, __setDbCatalogForTests, buildDatabaseImports, configureDbPersistence, DevDatabase, devDb, persistDb, setDbCatalog, } from './database.js';
 export { parseCatalog } from './catalog.js';
-export { freshDbState } from './types.js';
+export { CollectionFamily, DbFunctionKind, freshDbState } from './types.js';

package/build/devserver/db/routeKinds.d.ts

@@ -0,0 +1,8 @@
+import { DbFunctionKind } from './types.js';
+export interface RouteKindEntry {
+    readonly method: number;
+    readonly kind: DbFunctionKind;
+    readonly pattern: string;
+}
+export declare function parseRouteKinds(wasm: Buffer): readonly RouteKindEntry[];
+export declare function routeKindForRequest(routes: readonly RouteKindEntry[], method: string, path: string): DbFunctionKind | null;

package/build/devserver/db/routeKinds.js

@@ -0,0 +1,139 @@
+import { customSection } from '../wasm/sections.js';
+import { DbFunctionKind } from './types.js';
+const SECTION = 'toildb.route_kinds';
+const VERSION = 1;
+const MAX_SECTION_BYTES = 128 * 1024;
+const MAX_ROUTES = 2048;
+const MAX_PATTERN_BYTES = 2048;
+const UTF8_DECODER = new TextDecoder('utf-8', { fatal: true });
+const METHOD_CODES = {
+    GET: 0,
+    POST: 1,
+    PUT: 2,
+    DELETE: 3,
+    PATCH: 4,
+    HEAD: 5,
+    OPTIONS: 6,
+};
+export function parseRouteKinds(wasm) {
+    let section;
+    try {
+        section = customSection(wasm, SECTION);
+    }
+    catch {
+        return [];
+    }
+    if (section === null)
+        return [];
+    if (section.length > MAX_SECTION_BYTES)
+        return [];
+    const r = new Reader(section);
+    const version = r.u16();
+    if (!r.ok || version !== VERSION)
+        return [];
+    const count = r.u16();
+    if (!r.ok || count > MAX_ROUTES)
+        return [];
+    const routes = [];
+    for (let i = 0; i < count && r.ok; i++) {
+        const method = r.u8();
+        const kindByte = r.u8();
+        const pattern = r.string();
+        const kind = kindByte === 0 ? DbFunctionKind.Query : kindByte === 1 ? DbFunctionKind.Action : null;
+        if (!r.ok || method < 0 || method > 6 || kind === null || !validPattern(pattern))
+            return [];
+        routes.push({ method, kind, pattern });
+    }
+    if (!r.ok || r.remaining() !== 0)
+        return [];
+    return routes;
+}
+export function routeKindForRequest(routes, method, path) {
+    const methodCode = METHOD_CODES[method.toUpperCase()];
+    if (methodCode === undefined)
+        return null;
+    for (const route of routes) {
+        if (route.method === methodCode && routeMatches(route.pattern, path))
+            return route.kind;
+    }
+    return null;
+}
+function validPattern(pattern) {
+    if (pattern.length === 0 || !pattern.startsWith('/'))
+        return false;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern.charCodeAt(i);
+        if (c < 0x20 || c > 0x7e)
+            return false;
+    }
+    return true;
+}
+function routeMatches(pattern, pathWithQuery) {
+    const q = pathWithQuery.indexOf('?');
+    const path = q >= 0 ? pathWithQuery.slice(0, q) : pathWithQuery;
+    const patternSegs = pattern.split('/').filter(Boolean);
+    const pathSegs = path.split('/').filter(Boolean);
+    if (patternSegs.length !== pathSegs.length)
+        return false;
+    for (let i = 0; i < patternSegs.length; i++) {
+        const p = patternSegs[i] ?? '';
+        const a = pathSegs[i] ?? '';
+        if (p.startsWith(':') && p.length > 1 && a.length > 0)
+            continue;
+        if (p !== a)
+            return false;
+    }
+    return true;
+}
+class Reader {
+    bytes;
+    pos = 0;
+    ok = true;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    remaining() {
+        return this.bytes.length - this.pos;
+    }
+    u8() {
+        if (!this.ok || this.pos + 1 > this.bytes.length) {
+            this.ok = false;
+            return 0;
+        }
+        return this.bytes[this.pos++] ?? 0;
+    }
+    u16() {
+        if (!this.ok || this.pos + 2 > this.bytes.length) {
+            this.ok = false;
+            return 0;
+        }
+        const out = this.bytes.readUInt16LE(this.pos);
+        this.pos += 2;
+        return out;
+    }
+    u32() {
+        if (!this.ok || this.pos + 4 > this.bytes.length) {
+            this.ok = false;
+            return 0;
+        }
+        const out = this.bytes.readUInt32LE(this.pos);
+        this.pos += 4;
+        return out;
+    }
+    string() {
+        const len = this.u32();
+        if (!this.ok || len > MAX_PATTERN_BYTES || this.pos + len > this.bytes.length) {
+            this.ok = false;
+            return '';
+        }
+        try {
+            const out = UTF8_DECODER.decode(this.bytes.subarray(this.pos, this.pos + len));
+            this.pos += len;
+            return out;
+        }
+        catch {
+            this.ok = false;
+            return '';
+        }
+    }
+}

package/build/devserver/db/types.d.ts

@@ -1,7 +1,42 @@
+export declare enum CollectionFamily {
+    Record = 0,
+    View = 1,
+    Events = 2,
+    Counter = 3,
+    Membership = 4,
+    Unique = 5,
+    Capacity = 6
+}
+export declare enum DbFunctionKind {
+    Query = "query",
+    Action = "action",
+    Derive = "derive",
+    Job = "job",
+    Admin = "admin"
+}
+export declare function isCollectionFamily(value: number): value is CollectionFamily;
+export interface DevCollectionHandle {
+    name: string;
+    family: CollectionFamily;
+    schemaVersion: number;
+    replication: number;
+    placement: number;
+    fillMaxWaitMs: number;
+    fillAllowStale: boolean;
+}
+export type DbCatalogState = {
+    kind: 'no-section';
+} | {
+    kind: 'malformed';
+} | {
+    kind: 'present';
+    collections: Map<string, DevCollectionHandle>;
+};
 export interface DbDevState {
-    handles: string[];
+    handles: DevCollectionHandle[];
     lastResult: Buffer | null;
     lastResultVersion: number;
+    functionKind: DbFunctionKind;
 }
 export declare function freshDbState(): DbDevState;
 export interface Reservation {
@@ -19,6 +54,12 @@ export interface DbSnapshot {
         v: string;
         sv: number;
     }>;
+    recordIdem?: Record<string, {
+        requestHash: string;
+        state: 'pending' | 'done';
+        outcome?: RecordOutcomeSnapshot;
+    }>;
+    uniqueIdem?: Record<string, string>;
     views: Record<string, {
         v: string;
         sv: number;
@@ -28,6 +69,7 @@ export interface DbSnapshot {
         sv: number;
     }>>;
     counters: Record<string, string>;
+    counterIdem?: Record<string, string>;
     events: Record<string, {
         v: string;
         sv: number;
@@ -43,16 +85,37 @@ export interface DbSnapshot {
         }][];
     }>;
 }
+export type RecordOutcomeSnapshot = {
+    kind: 'unit';
+} | {
+    kind: 'value';
+    v: string;
+    sv: number;
+} | {
+    kind: 'absent';
+} | {
+    kind: 'already_exists';
+} | {
+    kind: 'not_found';
+} | {
+    kind: 'conflict';
+};
 export declare const MAX_RESERVATIONS = 4096;
 export declare const MAX_RESERVATION_TTL_MS = 86400000;
 export declare const MAX_NAME = 512;
 export declare const MAX_KEY = 4096;
 export declare const MAX_VALUE: number;
+export declare const DEFAULT_FILL_WAIT_MS = 50;
+export declare const MAX_FILL_WAIT_MS = 60000;
 export declare function satI64(v: bigint): bigint;
 export declare const ABSENT = -2;
 export declare const TOO_SMALL = -1;
 export declare const INVALID_HANDLE = -1001;
 export declare const ALREADY_EXISTS = -1003;
 export declare const CONFLICT = -1004;
+export declare const UNAVAILABLE = -1031;
 export declare const CODEC_ERR = -1006;
+export declare const OP_NOT_ALLOWED_FOR_FAMILY = -1010;
+export declare const OP_NOT_ALLOWED_IN_KIND = -1011;
 export declare const TOO_MANY_KEYS = -1020;
+export declare const SCHEMA_UNAVAILABLE = -1070;

package/build/devserver/db/types.js

@@ -1,11 +1,39 @@
+export var CollectionFamily;
+(function (CollectionFamily) {
+    CollectionFamily[CollectionFamily["Record"] = 0] = "Record";
+    CollectionFamily[CollectionFamily["View"] = 1] = "View";
+    CollectionFamily[CollectionFamily["Events"] = 2] = "Events";
+    CollectionFamily[CollectionFamily["Counter"] = 3] = "Counter";
+    CollectionFamily[CollectionFamily["Membership"] = 4] = "Membership";
+    CollectionFamily[CollectionFamily["Unique"] = 5] = "Unique";
+    CollectionFamily[CollectionFamily["Capacity"] = 6] = "Capacity";
+})(CollectionFamily || (CollectionFamily = {}));
+export var DbFunctionKind;
+(function (DbFunctionKind) {
+    DbFunctionKind["Query"] = "query";
+    DbFunctionKind["Action"] = "action";
+    DbFunctionKind["Derive"] = "derive";
+    DbFunctionKind["Job"] = "job";
+    DbFunctionKind["Admin"] = "admin";
+})(DbFunctionKind || (DbFunctionKind = {}));
+export function isCollectionFamily(value) {
+    return value >= CollectionFamily.Record && value <= CollectionFamily.Capacity;
+}
 export function freshDbState() {
-    return { handles: [], lastResult: null, lastResultVersion: -1 };
+    return {
+        handles: [],
+        lastResult: null,
+        lastResultVersion: -1,
+        functionKind: DbFunctionKind.Job,
+    };
 }
 export const MAX_RESERVATIONS = 4096;
 export const MAX_RESERVATION_TTL_MS = 86_400_000;
 export const MAX_NAME = 512;
 export const MAX_KEY = 4096;
 export const MAX_VALUE = 256 * 1024;
+export const DEFAULT_FILL_WAIT_MS = 50;
+export const MAX_FILL_WAIT_MS = 60_000;
 const I64_MIN = -(2n ** 63n);
 const I64_MAX = 2n ** 63n - 1n;
 export function satI64(v) {
@@ -16,5 +44,9 @@ export const TOO_SMALL = -1;
 export const INVALID_HANDLE = -1001;
 export const ALREADY_EXISTS = -1003;
 export const CONFLICT = -1004;
+export const UNAVAILABLE = -1031;
 export const CODEC_ERR = -1006;
+export const OP_NOT_ALLOWED_FOR_FAMILY = -1010;
+export const OP_NOT_ALLOWED_IN_KIND = -1011;
 export const TOO_MANY_KEYS = -1020;
+export const SCHEMA_UNAVAILABLE = -1070;

package/build/devserver/index.d.ts

@@ -7,3 +7,13 @@ export type { WasmDispatchResult } from './runtime/module.js';
 export { buildHostImports, freshDispatchState } from './runtime/host.js';
 export type { DispatchState, MemoryRef } from './runtime/host.js';
 export type { ViteTarget } from './http/proxy.js';
+export { DaemonHost, daemonEmulationEnabled } from './daemon/index.js';
+export { parseDaemonCatalog } from './daemon/catalog.js';
+export type { DaemonCatalog, ScheduledTask, CronMasks } from './daemon/catalog.js';
+export { buildDaemonImports, freshDaemonState } from './daemon/host.js';
+export type { DaemonState, DaemonRuntime, ResolvedDaemonConfig } from './daemon/host.js';
+export { cronMatches, cronNeverFires, nextCronFireMs } from './daemon/cron.js';
+export { parseSurface } from './wasm/surface.js';
+export type { Surface, SurfaceFlags } from './wasm/surface.js';
+export { customSection } from './wasm/sections.js';
+export { DevMemoryStore, devMemoryStore } from './mstore/store.js';

package/build/devserver/index.js

@@ -2,3 +2,10 @@ export { startDevServer } from './server.js';
 export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './http/envelope.js';
 export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './runtime/module.js';
 export { buildHostImports, freshDispatchState } from './runtime/host.js';
+export { DaemonHost, daemonEmulationEnabled } from './daemon/index.js';
+export { parseDaemonCatalog } from './daemon/catalog.js';
+export { buildDaemonImports, freshDaemonState } from './daemon/host.js';
+export { cronMatches, cronNeverFires, nextCronFireMs } from './daemon/cron.js';
+export { parseSurface } from './wasm/surface.js';
+export { customSection } from './wasm/sections.js';
+export { DevMemoryStore, devMemoryStore } from './mstore/store.js';

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,82 @@
+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/build/devserver/runtime/host.d.ts

@@ -16,4 +16,10 @@ export declare function freshDispatchState(): DispatchState;
 export interface MemoryRef {
     memory: WebAssembly.Memory | null;
 }
+export declare function readBytes(ref: MemoryRef, ptr: number, len: number): Buffer;
+export declare function writeBytesOut(ref: MemoryRef, bytes: Buffer, outPtr: number, outCap: number): number;
+export declare function buildEnvImports(ref: MemoryRef, _state: {
+    crypto: CryptoState;
+    db: DbDevState;
+}): Record<string, (...a: never[]) => unknown>;
 export declare function buildHostImports(ref: MemoryRef, state: DispatchState): WebAssembly.Imports;

package/build/devserver/runtime/host.js

@@ -32,12 +32,21 @@ function mem(ref) {
         throw new Error('host import called before memory was bound');
     return Buffer.from(ref.memory.buffer);
 }
-function readBytes(ref, ptr, len) {
+export function readBytes(ref, ptr, len) {
     const m = mem(ref);
     if (ptr < 0 || len < 0 || ptr + len > m.length)
         throw new Error(`host import read out of bounds: ptr=${String(ptr)} len=${String(len)}`);
     return m.subarray(ptr, ptr + len);
 }
+export function writeBytesOut(ref, bytes, outPtr, outCap) {
+    if (bytes.length > outCap)
+        return -1;
+    const m = mem(ref);
+    if (outPtr < 0 || outPtr + bytes.length > m.length)
+        throw new Error('host import write out of bounds');
+    bytes.copy(m, outPtr);
+    return bytes.length;
+}
 function readGuestString(ref, ptr) {
     if (ptr === 0)
         return '';
@@ -80,6 +89,41 @@ function envLookup(ref, keyPtr, keyLen, outPtr, outCap, secure) {
     bytes.copy(m, outPtr);
     return bytes.length;
 }
+export function buildEnvImports(ref, _state) {
+    return {
+        abort: (msgPtr, filePtr, line, col) => {
+            throw new WasmAbortError(readGuestString(ref, msgPtr), readGuestString(ref, filePtr), line, col);
+        },
+        env_get: (keyPtr, keyLen, outPtr, outCap) => envLookup(ref, keyPtr, keyLen, outPtr, outCap, false),
+        env_get_secure: (keyPtr, keyLen, outPtr, outCap) => envLookup(ref, keyPtr, keyLen, outPtr, outCap, true),
+        thread_spawn: (_startArg) => -1,
+        'Date.now': () => BigInt(Date.now()),
+        email_send: (reqPtr, reqLen) => {
+            const raw = readBytes(ref, reqPtr, reqLen);
+            const svc = getEmailService();
+            if (svc === null) {
+                const to = parseEmailBlob(raw)?.to ?? '<unparsed>';
+                process.stdout.write(`  ✉ dev email_send -> ${to} (no email config; not sent)\n`);
+                return EmailStatus.Sent;
+            }
+            const { status, parsed } = svc.prepare(raw);
+            if (parsed === null) {
+                process.stdout.write(`  ✉ dev email_send -> ${EmailStatus[status]}\n`);
+                return status;
+            }
+            void svc
+                .deliver(parsed)
+                .then((s) => {
+                const label = s === EmailStatus.Sent ? 'sent' : EmailStatus[s];
+                process.stdout.write(`  ✉ dev email_send -> ${parsed.to} (${label})\n`);
+            })
+                .catch((e) => {
+                process.stdout.write(`  ✉ dev email_send -> ${parsed.to} (error: ${String(e)})\n`);
+            });
+            return EmailStatus.Sent;
+        },
+    };
+}
 export function buildHostImports(ref, state) {
     return {
         env: {

package/build/devserver/runtime/module.d.ts

@@ -12,6 +12,7 @@ export declare class WasmServerModule {
     private readonly wasmPath;
     private module;
     private loadedMtimeMs;
+    private routeKinds;
     constructor(wasmPath: string);
     get available(): boolean;
     refresh(): boolean;

package/build/devserver/runtime/module.js

@@ -1,10 +1,25 @@
 import fs from 'node:fs';
-import { persistDb, setDbCatalog } from '../db/index.js';
+import { DbFunctionKind, persistDb, setDbCatalog } from '../db/index.js';
+import { parseRouteKinds, routeKindForRequest } from '../db/routeKinds.js';
 import { decodeResponseEnvelope, encodeRequestEnvelope, unpackHandleResult, } from '../http/envelope.js';
 import { buildHostImports, freshDispatchState } from './host.js';
 export { WasmAbortError } from './host.js';
 export const UNHANDLED_HEADER = 'x-toil-unhandled';
 const WASM_PAGE = 65536;
+function dbKindForHttpMethod(method) {
+    switch (method.toUpperCase()) {
+        case 'GET':
+        case 'HEAD':
+        case 'OPTIONS':
+            return DbFunctionKind.Query;
+        case 'POST':
+        case 'PUT':
+        case 'PATCH':
+        case 'DELETE':
+        default:
+            return DbFunctionKind.Action;
+    }
+}
 const PROVIDED_IMPORTS = new Set([
     'abort',
     'set_status',
@@ -67,6 +82,7 @@ export class WasmServerModule {
     wasmPath;
     module = null;
     loadedMtimeMs = -1;
+    routeKinds = [];
     constructor(wasmPath) {
         this.wasmPath = wasmPath;
     }
@@ -80,6 +96,7 @@ export class WasmServerModule {
         }
         catch {
             this.module = null;
+            this.routeKinds = [];
             this.loadedMtimeMs = -1;
             return false;
         }
@@ -90,6 +107,7 @@ export class WasmServerModule {
         this.assertImportSurface(module);
         this.assertExportSurface(module);
         setDbCatalog(bytes);
+        this.routeKinds = parseRouteKinds(bytes);
         this.module = module;
         this.loadedMtimeMs = mtimeMs;
         return true;
@@ -101,6 +119,13 @@ export class WasmServerModule {
         const ref = { memory: null };
         const state = freshDispatchState();
         state.clientIp = req.clientIp ?? '';
+        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);
         const instance = new WebAssembly.Instance(this.module, buildHostImports(ref, state));
         const exports = instance.exports;
         ref.memory = exports.memory;
@@ -132,6 +157,7 @@ export class WasmServerModule {
         const ref = { memory: null };
         const state = freshDispatchState();
         state.clientIp = req.clientIp ?? '';
+        state.db.functionKind = DbFunctionKind.Query;
         const instance = new WebAssembly.Instance(this.module, buildHostImports(ref, state));
         const exports = instance.exports;
         if (typeof exports.render !== 'function')

package/build/devserver/server.d.ts

@@ -1,13 +1,19 @@
 import type { EmailBackendConfig } from 'toiljs/shared';
+import type { ResolvedDaemonConfig } from './daemon/host.js';
 import { type ViteTarget } from './http/proxy.js';
+import { type DevSsrTemplate } from './ssr.js';
 export interface DevServerOptions {
     readonly root: string;
     readonly port: number;
     readonly host?: string;
     readonly wasmFile: string;
+    readonly coldWasmFile?: string;
+    readonly nodeMode?: string;
+    readonly daemon?: ResolvedDaemonConfig;
     readonly vite: ViteTarget;
     readonly maxBodyLength?: number;
     readonly email?: EmailBackendConfig;
+    readonly ssrTemplates?: readonly DevSsrTemplate[];
 }
 export interface RunningDevServer {
     readonly port: number;