toiljs 0.0.116 → 0.0.118

package/test/devserver.test.ts

@@ -1,259 +0,0 @@
-/**
- * WASM dev server: envelope codec (byte-for-byte against the ABI shared with
- * `server/runtime/envelope.ts` and the edge's `envelope.rs`) and real dispatch
- * into the example project's ToilScript-compiled server wasm.
- */
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { describe, expect, it } from 'vitest';
-
-import {
-    decodeResponseEnvelope,
-    encodeRequestEnvelope,
-    unpackHandleResult,
-    WasmServerModule,
-} from '../src/devserver/index.js';
-import { resolveStaticFile } from '../src/devserver/http/runtime.js';
-
-const EXAMPLE_WASM = path.resolve(
-    path.dirname(fileURLToPath(import.meta.url)),
-    '../examples/basic/build/server/release.wasm',
-);
-
-describe('request envelope encoding', () => {
-    it('encodes a minimal GET / exactly like the edge', () => {
-        const out = encodeRequestEnvelope({
-            method: 'GET',
-            path: '/',
-            headers: [],
-            body: new Uint8Array(0),
-        });
-        // Mirrors envelope.rs `encode_minimal_get`.
-        expect(out.length).toBe(10);
-        expect(out[0]).toBe(0); // method GET
-        expect(out.readUInt16LE(1)).toBe(1); // path_len
-        expect(out.toString('utf8', 3, 4)).toBe('/');
-        expect(out.readUInt16LE(4)).toBe(0); // n_headers
-        expect(out.readUInt32LE(6)).toBe(0); // body_len
-    });
-
-    it('encodes a POST with a header and body exactly like the edge', () => {
-        const out = encodeRequestEnvelope({
-            method: 'POST',
-            path: '/api',
-            headers: [['host', 'example.com']],
-            body: new TextEncoder().encode('hi'),
-        });
-        // Mirrors envelope.rs `encode_post_with_body_and_host`.
-        expect(out[0]).toBe(1); // method POST
-        expect(out.readUInt16LE(1)).toBe(4);
-        expect(out.toString('utf8', 3, 7)).toBe('/api');
-        expect(out.readUInt16LE(7)).toBe(1); // n_headers
-        expect(out.readUInt16LE(9)).toBe(4); // name_len
-        expect(out.readUInt16LE(11)).toBe(11); // val_len
-        expect(out.toString('utf8', 13, 17)).toBe('host');
-        expect(out.toString('utf8', 17, 28)).toBe('example.com');
-        expect(out.readUInt32LE(28)).toBe(2); // body_len
-        expect(out.toString('utf8', 32, 34)).toBe('hi');
-    });
-
-    it('rejects an unsupported method and oversized fields', () => {
-        const base = { path: '/', headers: [], body: new Uint8Array(0) } as const;
-        expect(() => encodeRequestEnvelope({ ...base, method: 'TRACE' })).toThrow(/unsupported/);
-        expect(() =>
-            encodeRequestEnvelope({ ...base, method: 'GET', path: '/'.repeat(0x10000) }),
-        ).toThrow(/path too long/);
-        expect(() =>
-            encodeRequestEnvelope({
-                ...base,
-                method: 'GET',
-                headers: [['x', 'y'.repeat(0x10000)]],
-            }),
-        ).toThrow(/header too long/);
-    });
-});
-
-/** Hand-builds a response envelope (the layout the guest writes). */
-function buildResponse(status: number, headers: [string, string][], body: Uint8Array): Buffer {
-    const parts: Buffer[] = [];
-    const u16 = (v: number): Buffer => {
-        const b = Buffer.allocUnsafe(2);
-        b.writeUInt16LE(v);
-        return b;
-    };
-    const u32 = (v: number): Buffer => {
-        const b = Buffer.allocUnsafe(4);
-        b.writeUInt32LE(v);
-        return b;
-    };
-    parts.push(u16(status), u16(headers.length));
-    for (const [n, v] of headers) {
-        parts.push(u16(Buffer.byteLength(n)), u16(Buffer.byteLength(v)));
-        parts.push(Buffer.from(n), Buffer.from(v));
-    }
-    parts.push(u32(body.length), Buffer.from(body));
-    return Buffer.concat(parts);
-}
-
-describe('response envelope decoding', () => {
-    it('round-trips status, headers and body', () => {
-        const buf = buildResponse(
-            201,
-            [
-                ['content-type', 'application/json'],
-                ['x-trace', 'abc'],
-            ],
-            new TextEncoder().encode('{"ok":true}'),
-        );
-        const resp = decodeResponseEnvelope(buf);
-        expect(resp.status).toBe(201);
-        expect(resp.headers).toEqual([
-            ['content-type', 'application/json'],
-            ['x-trace', 'abc'],
-        ]);
-        expect(Buffer.from(resp.body).toString()).toBe('{"ok":true}');
-    });
-
-    it('rejects truncation, zero status, and overflowing lengths', () => {
-        expect(() => decodeResponseEnvelope(new Uint8Array([1]))).toThrow(/truncated/);
-        expect(() => decodeResponseEnvelope(buildResponse(0, [], new Uint8Array(0)))).toThrow(
-            /status 0/,
-        );
-        // Claim a huge header name with too few bytes behind it.
-        const bad = Buffer.concat([Buffer.from([200, 0, 1, 0, 255, 255, 0, 0]), Buffer.from('hi')]);
-        expect(() => decodeResponseEnvelope(bad)).toThrow(/truncated/);
-    });
-});
-
-describe('handle() result unpacking', () => {
-    it('splits the packed i64 into pointer and length', () => {
-        expect(unpackHandleResult((65536n << 32n) | 8n)).toEqual({ ptr: 65536, len: 8 });
-        expect(unpackHandleResult(0n)).toEqual({ ptr: 0, len: 0 });
-        expect(unpackHandleResult(0xffffffff_ffffffffn)).toEqual({
-            ptr: 0xffffffff,
-            len: 0xffffffff,
-        });
-    });
-});
-
-describe('static file resolver', () => {
-    it('resolves absolute request paths inside the static root', () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'toil-static-'));
-        const file = path.join(root, 'assets', 'app.css');
-        try {
-            fs.mkdirSync(path.dirname(file), { recursive: true });
-            fs.writeFileSync(file, 'body{}');
-
-            expect(resolveStaticFile(root, '/assets/app.css')).toBe(file);
-            expect(resolveStaticFile(root, '/missing.css')).toBeNull();
-            expect(resolveStaticFile(root, '/../app.css')).toBeNull();
-        } finally {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    });
-});
-
-describe.skipIf(!fs.existsSync(EXAMPLE_WASM))('dispatch into the example server wasm', () => {
-    const load = (): WasmServerModule => {
-        const m = new WasmServerModule(EXAMPLE_WASM);
-        m.refresh();
-        return m;
-    };
-    const get = (m: WasmServerModule, p: string) =>
-        m.dispatch({
-            method: 'GET',
-            path: p,
-            headers: [['host', 'localhost:3000']],
-            body: new Uint8Array(0),
-        });
-
-    it('serves a plain route', () => {
-        const r = get(load(), '/json');
-        expect(r.status).toBe(200);
-        expect(r.unhandled).toBe(false);
-        expect(Buffer.from(r.body).toString()).toBe('{"hello":"toiljs"}\n');
-    });
-
-    it('serves a @rest route with its content-type', () => {
-        const r = get(load(), '/leaderboard');
-        expect(r.status).toBe(200);
-        expect(r.headers.some(([n, v]) => n === 'content-type' && v.includes('json'))).toBe(true);
-    });
-
-    it('marks a route miss as unhandled and strips the marker header', () => {
-        const r = get(load(), '/definitely-missing');
-        expect(r.status).toBe(404);
-        expect(r.unhandled).toBe(true);
-        expect(r.headers.some(([n]) => n === 'x-toil-unhandled')).toBe(false);
-    });
-
-    it('dispatches a POST body through the envelope', () => {
-        const m = load();
-        const r = m.dispatch({
-            method: 'POST',
-            path: '/players',
-            headers: [
-                ['host', 'localhost:3000'],
-                ['content-type', 'application/json'],
-            ],
-            body: new TextEncoder().encode('{"name":"ada"}'),
-        });
-        expect(r.unhandled).toBe(false);
-        expect(r.status).toBe(200);
-        // u256 id and i64 score cross JSON as decimal strings, exact at any size (3 seeded
-        // players, so the new player's id is 4).
-        expect(Buffer.from(r.body).toString()).toBe('{"id":"4","name":"ada","score":"0"}');
-    });
-
-    it('keeps requests isolated across instances (fresh state per dispatch)', () => {
-        const m = load();
-        const a = get(m, '/json');
-        const b = get(m, '/json');
-        expect(Buffer.from(a.body).toString()).toBe(Buffer.from(b.body).toString());
-    });
-
-    // Exercises `SecureCookies` (HMAC-SHA256) end-to-end through the real
-    // toilscript-compiled wasm with the Node-backed `env.crypto.*` host imports:
-    // `/api/cookies/set` seals a signed `__Host-session`, `/api/cookies/inspect`
-    // parses + verifies it. (as-pect cannot compile the crypto std, so this is its coverage.)
-    const sessionCookie = (m: WasmServerModule): string => {
-        const res = get(m, '/api/cookies/set');
-        expect(res.status).toBe(200);
-        const pair = res.headers
-            .filter(([n]) => n === 'set-cookie')
-            .map(([, v]) => v.split(';')[0])
-            .find((v) => v.startsWith('__Host-session='));
-        expect(pair).toBeDefined();
-        return pair!; // "__Host-session=<sealed>"
-    };
-    const inspect = (m: WasmServerModule, cookie: string): string =>
-        Buffer.from(
-            m.dispatch({
-                method: 'GET',
-                path: '/api/cookies/inspect',
-                headers: [
-                    ['host', 'localhost:3000'],
-                    ['cookie', cookie],
-                ],
-                body: new Uint8Array(0),
-            }).body,
-        ).toString();
-
-    it('round-trips a signed cookie (SecureCookies sign -> unsign)', () => {
-        const m = load();
-        expect(inspect(m, sessionCookie(m))).toContain('"session":"user-42"');
-    });
-
-    it('rejects a tampered signed cookie', () => {
-        const m = load();
-        const pair = sessionCookie(m);
-        const eq = pair.indexOf('=');
-        const name = pair.slice(0, eq);
-        const val = pair.slice(eq + 1);
-        const tampered = `${name}=${val[0] === 'A' ? 'B' : 'A'}${val.slice(1)}`;
-        expect(inspect(m, tampered)).toContain('"session":null');
-    });
-});

package/test/doctor.test.ts

@@ -1,298 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-    checkAuthSecrets,
-    checkBasePath,
-    checkDevScripts,
-    checkDuplicatePatterns,
-    type CheckGroup,
-    checkMigrationsDir,
-    checkMountSlots,
-    checkNode,
-    checkPeer,
-    checkPrettierPlugin,
-    checkRelativeAssets,
-    checkRestDispatch,
-    checkRootElement,
-    checkRpcWiring,
-    checkSeoUrl,
-    checkServerTsPlugin,
-    checkStyling,
-    checkTypeScript,
-    findRelativeAssets,
-    rangeMajor,
-    satisfiesMin,
-    summarize,
-} from '../src/cli/diagnostics';
-
-describe('satisfiesMin', () => {
-    it('compares against a >= minimum, ignoring range prefixes', () => {
-        expect(satisfiesMin('25.8.0', '>=24.0.0')).toBe(true);
-        expect(satisfiesMin('20.0.0', '>=24.0.0')).toBe(false);
-        expect(satisfiesMin('^19.2.6', '>=18.0.0')).toBe(true); // declared caret range, compared by floor
-        expect(satisfiesMin('6.0.0', '>=6.0.0')).toBe(true);
-        expect(satisfiesMin('5.9.9', '>=6.0.0')).toBe(false);
-    });
-});
-
-describe('checkMountSlots', () => {
-    it('warns when mount() omits slots, passes when present', () => {
-        expect(checkMountSlots('Toil.mount(routes, layout, notFound, globalError);').status).toBe(
-            'warn',
-        );
-        expect(
-            checkMountSlots('Toil.mount(routes, layout, notFound, globalError, slots);').status,
-        ).toBe('pass');
-    });
-
-    it('warns when there is no entry or no mount() call', () => {
-        expect(checkMountSlots(null).status).toBe('warn');
-        expect(checkMountSlots('export const x = 1;').status).toBe('warn');
-    });
-});
-
-describe('findRelativeAssets / checkRelativeAssets', () => {
-    it('flags root-relative asset paths but not absolute, url, or expression refs', () => {
-        const issues = findRelativeAssets([
-            {
-                path: 'client/components/Header.tsx',
-                source: [
-                    '<img src="images/logo.svg" />', // broken: relative asset
-                    '<img src="/images/logo.svg" />', // ok: root-absolute
-                    '<img src="https://cdn/x.png" />', // ok: url
-                    '<img src={logo} />', // ok: expression (not a string literal)
-                    '<a href="/about">about</a>', // ok: no extension, route
-                ].join('\n'),
-            },
-        ]);
-        expect(issues).toHaveLength(1);
-        expect(issues[0]).toMatchObject({ line: 1, value: 'images/logo.svg' });
-        expect(checkRelativeAssets(issues).status).toBe('warn');
-        expect(checkRelativeAssets([]).status).toBe('pass');
-    });
-});
-
-describe('config + environment checks', () => {
-    it('checkBasePath: root or wrapped in slashes passes, otherwise warns', () => {
-        expect(checkBasePath('/').status).toBe('pass');
-        expect(checkBasePath('/app/').status).toBe('pass');
-        expect(checkBasePath('/app').status).toBe('warn');
-    });
-
-    it('checkSeoUrl: warns only when seo is configured without a url', () => {
-        expect(checkSeoUrl(false, false).status).toBe('pass');
-        expect(checkSeoUrl(true, true).status).toBe('pass');
-        expect(checkSeoUrl(true, false).status).toBe('warn');
-    });
-
-    it('checkNode / checkPeer reflect version satisfaction', () => {
-        expect(checkNode('25.0.0', '>=24.0.0').status).toBe('pass');
-        expect(checkNode('18.0.0', '>=24.0.0').status).toBe('fail');
-        expect(checkPeer('react', null, '>=18.0.0').status).toBe('fail');
-        expect(checkPeer('react', '^17.0.0', '>=18.0.0').status).toBe('warn');
-        expect(checkPeer('react', '^19.0.0', '>=18.0.0').status).toBe('pass');
-    });
-
-    it('checkTypeScript fails an installed 7.x (the native port, no compiler API)', () => {
-        const check = checkTypeScript('7.0.2', '^7.0.2');
-        expect(check.status).toBe('fail');
-        expect(check.detail).toContain('7.0.2');
-        expect(check.fix).toContain('^6.0.3');
-    });
-
-    it('checkTypeScript fails a declared 7.x even while a supported copy is installed', () => {
-        // The installed copy still works, but the next install would pull the native port.
-        expect(checkTypeScript('6.0.3', '^7.0.0').status).toBe('fail');
-        expect(checkTypeScript('6.0.3', '>=7').status).toBe('fail');
-    });
-
-    it('checkTypeScript passes a supported 6.x and warns below the floor', () => {
-        expect(checkTypeScript('6.0.3', '^6.0.3').status).toBe('pass');
-        expect(checkTypeScript('5.9.3', '^5.9.0').status).toBe('warn');
-        expect(checkTypeScript(null, null).status).toBe('fail');
-    });
-
-    it('rangeMajor reads the major a range floats to, ignoring comparators', () => {
-        expect(rangeMajor('^7.0.2')).toBe(7);
-        expect(rangeMajor('>=6.0.0 <7.0.0')).toBe(6);
-        expect(rangeMajor('~6.0')).toBe(6);
-        expect(rangeMajor('*')).toBe(null);
-    });
-
-    it('checkDuplicatePatterns flags repeated route URLs', () => {
-        expect(checkDuplicatePatterns(['/', '/about', '/blog/:id']).status).toBe('pass');
-        expect(checkDuplicatePatterns(['/a', '/a']).status).toBe('warn');
-    });
-
-    it('checkRootElement requires an id="root" mount target', () => {
-        expect(checkRootElement('<div id="root"></div>').status).toBe('pass');
-        expect(checkRootElement('<div id="app"></div>').status).toBe('fail');
-        expect(checkRootElement(null).status).toBe('fail');
-    });
-
-    it('checkStyling fails when an imported preprocessor/Tailwind is not installed', () => {
-        expect(
-            checkStyling({
-                preprocessorImported: 'sass',
-                preprocessorInstalled: false,
-                tailwindImported: false,
-                tailwindInstalled: false,
-            }).status,
-        ).toBe('fail');
-        expect(
-            checkStyling({
-                preprocessorImported: 'sass',
-                preprocessorInstalled: true,
-                tailwindImported: true,
-                tailwindInstalled: false,
-            }).status,
-        ).toBe('fail');
-        expect(
-            checkStyling({
-                preprocessorImported: 'css',
-                preprocessorInstalled: true,
-                tailwindImported: false,
-                tailwindInstalled: false,
-            }).status,
-        ).toBe('pass');
-    });
-});
-
-describe('checkRpcWiring', () => {
-    const wired = {
-        buildServerWired: true,
-        tsconfigWired: true,
-        gitignoreWired: true,
-        toilscriptOk: true,
-    };
-
-    it('passes when fully wired', () => {
-        expect(checkRpcWiring(wired).status).toBe('pass');
-    });
-
-    it('warns and lists every missing piece', () => {
-        const c = checkRpcWiring({
-            buildServerWired: false,
-            tsconfigWired: false,
-            gitignoreWired: false,
-            toilscriptOk: false,
-        });
-        expect(c.status).toBe('warn');
-        expect(c.detail).toContain('toilscript');
-        expect(c.detail).toContain('--rpcModule');
-        expect(c.detail).toContain('tsconfig');
-        expect(c.detail).toContain('.gitignore');
-        expect(c.fix).toContain('--fix');
-    });
-
-    it('warns on a single missing piece', () => {
-        const c = checkRpcWiring({ ...wired, gitignoreWired: false });
-        expect(c.status).toBe('warn');
-        expect(c.detail).toContain('.gitignore');
-    });
-});
-
-describe('checkRestDispatch', () => {
-    it('passes when there are no @rest controllers', () => {
-        expect(checkRestDispatch({ hasControllers: false, dispatched: false }).status).toBe('pass');
-    });
-
-    it('passes when controllers are dispatched', () => {
-        expect(checkRestDispatch({ hasControllers: true, dispatched: true }).status).toBe('pass');
-    });
-
-    it('warns when controllers exist but nothing dispatches them', () => {
-        const c = checkRestDispatch({ hasControllers: true, dispatched: false });
-        expect(c.status).toBe('warn');
-        expect(c.detail).toContain('Rest.dispatch');
-        expect(c.fix).toContain('RestHandler');
-    });
-});
-
-describe('checkPrettierPlugin', () => {
-    it('passes when present', () => {
-        expect(checkPrettierPlugin(true).status).toBe('pass');
-    });
-    it('warns (not fails) when missing, pointing at --fix', () => {
-        const c = checkPrettierPlugin(false);
-        expect(c.status).toBe('warn');
-        expect(c.fix).toContain('--fix');
-    });
-});
-
-describe('checkServerTsPlugin', () => {
-    it('passes when the toilscript LS plugin is wired', () => {
-        expect(checkServerTsPlugin(true).status).toBe('pass');
-    });
-    it('warns (not fails) when missing, naming the TS2339 false positive and --fix', () => {
-        const c = checkServerTsPlugin(false);
-        expect(c.status).toBe('warn');
-        expect(c.detail).toContain('TS2339');
-        expect(c.fix).toContain('--fix');
-    });
-});
-
-describe('checkAuthSecrets', () => {
-    it('passes when auth is not used', () => {
-        expect(checkAuthSecrets({ usesAuth: false, sessionSecretSet: false }).status).toBe('pass');
-    });
-    it('passes when auth is used and the session secret is set', () => {
-        expect(checkAuthSecrets({ usesAuth: true, sessionSecretSet: true }).status).toBe('pass');
-    });
-    it('warns about session forgery when auth is used but the secret is unset', () => {
-        const c = checkAuthSecrets({ usesAuth: true, sessionSecretSet: false });
-        expect(c.status).toBe('warn');
-        expect(c.detail).toContain('AUTH_SESSION_SECRET');
-        expect(c.detail).toContain('forge');
-        expect(c.fix).toContain('.env.secrets');
-    });
-});
-
-describe('checkMigrationsDir', () => {
-    it('passes when the server/migrations/ folder exists', () => {
-        expect(checkMigrationsDir(true).status).toBe('pass');
-    });
-    it('warns (not fails) when missing, naming the convention and the update fix', () => {
-        const c = checkMigrationsDir(false);
-        expect(c.status).toBe('warn');
-        expect(c.detail).toContain('migration.ts');
-        expect(c.fix).toContain('toiljs update');
-    });
-});
-
-describe('summarize', () => {
-    it('tallies pass/warn/fail across groups', () => {
-        const groups: CheckGroup[] = [
-            {
-                title: 'A',
-                checks: [
-                    { id: '1', label: 'x', status: 'pass' },
-                    { id: '2', label: 'y', status: 'warn' },
-                ],
-            },
-            { title: 'B', checks: [{ id: '3', label: 'z', status: 'fail' }] },
-        ];
-        expect(summarize(groups)).toEqual({ pass: 1, warn: 1, fail: 1 });
-    });
-});
-
-describe('checkDevScripts', () => {
-    it('passes when no script wraps toiljs in npx', () => {
-        const c = checkDevScripts({ dev: 'toiljs dev', build: 'toiljs build' });
-        expect(c.status).toBe('pass');
-    });
-
-    it('warns and names the offending scripts using npx toiljs', () => {
-        const c = checkDevScripts({ dev: 'npx toiljs dev', build: 'toiljs build' });
-        expect(c.status).toBe('warn');
-        expect(c.detail).toContain('dev');
-        expect(c.detail).not.toContain('build');
-        expect(c.fix).toMatch(/toiljs <cmd>/);
-    });
-
-    it('does not flag unrelated npx usage or substrings', () => {
-        expect(checkDevScripts({ x: 'npx create-toiljs my-app' }).status).toBe('pass');
-        expect(checkDevScripts({ x: 'echo npxtoiljs' }).status).toBe('pass');
-        expect(checkDevScripts({}).status).toBe('pass');
-    });
-});