fastscript 0.1.0

package/scripts/bench-report.mjs

@@ -0,0 +1,36 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { gzipSync } from "node:zlib";
+import { performance } from "node:perf_hooks";
+import { runBuild } from "../src/build.mjs";
+
+function gzipSize(path) {
+  if (!existsSync(path)) return 0;
+  return gzipSync(readFileSync(path), { level: 9 }).byteLength;
+}
+
+function kb(n) {
+  return (n / 1024).toFixed(2);
+}
+
+const t0 = performance.now();
+await runBuild();
+const t1 = performance.now();
+
+const dist = resolve('dist');
+const manifest = JSON.parse(readFileSync(join(dist, 'fastscript-manifest.json'), 'utf8'));
+const jsAssets = [join(dist, 'router.js')];
+if (manifest.layout) jsAssets.push(join(dist, manifest.layout.replace(/^\.\//, '')));
+const home = manifest.routes.find((r) => r.path === '/');
+if (home?.module) jsAssets.push(join(dist, home.module.replace(/^\.\//, '')));
+const cssAssets = [join(dist, 'styles.css')];
+
+const js = jsAssets.reduce((s, p) => s + gzipSize(p), 0);
+const css = cssAssets.reduce((s, p) => s + gzipSize(p), 0);
+
+const md = `# FastScript Benchmark Report\n\n- Build time: ${(t1 - t0).toFixed(2)}ms\n- Routes: ${manifest.routes.length}\n- API routes: ${manifest.apiRoutes?.length ?? 0}\n- JS first-load gzip: ${kb(js)}KB\n- CSS first-load gzip: ${kb(css)}KB\n\n## Budgets\n- JS budget (30KB): ${js <= 30 * 1024 ? 'PASS' : 'FAIL'}\n- CSS budget (10KB): ${css <= 10 * 1024 ? 'PASS' : 'FAIL'}\n`;
+
+const outDir = resolve('benchmarks');
+mkdirSync(outDir, { recursive: true });
+writeFileSync(join(outDir, 'latest-report.md'), md, 'utf8');
+console.log('bench report written: benchmarks/latest-report.md');

package/scripts/release.mjs

@@ -0,0 +1,21 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+
+const pkgPath = "package.json";
+const changelogPath = "CHANGELOG.md";
+
+const level = process.argv[2] || "patch";
+const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+const [maj, min, pat] = pkg.version.split(".").map(Number);
+let next = [maj, min, pat];
+if (level === "major") next = [maj + 1, 0, 0];
+else if (level === "minor") next = [maj, min + 1, 0];
+else next = [maj, min, pat + 1];
+
+pkg.version = next.join(".");
+writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+
+const entry = `## v${pkg.version} - ${new Date().toISOString().slice(0, 10)}\n- release prep\n\n`;
+const prev = existsSync(changelogPath) ? readFileSync(changelogPath, "utf8") : "# Changelog\n\n";
+writeFileSync(changelogPath, prev + entry, "utf8");
+
+console.log(`version bumped to ${pkg.version}`);

package/scripts/smoke-dev.mjs

@@ -0,0 +1,78 @@
+import { spawn } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+
+async function waitFor(url, ms = 20000) {
+  const start = Date.now();
+  let lastErr = null;
+  while (Date.now() - start < ms) {
+    try {
+      const r = await fetch(url);
+      if (r.status >= 200 && r.status < 600) return r;
+    } catch (e) {
+      lastErr = e;
+    }
+    await sleep(300);
+  }
+  throw new Error(`Timeout waiting for ${url}${lastErr ? `: ${lastErr.message}` : ""}`);
+}
+
+const proc = spawn(process.execPath, ["./src/cli.mjs", "dev"], {
+  cwd: process.cwd(),
+  stdio: ["ignore", "pipe", "pipe"],
+  env: { ...process.env },
+});
+
+let output = "";
+proc.stdout.on("data", (d) => (output += d.toString()));
+proc.stderr.on("data", (d) => (output += d.toString()));
+
+try {
+  await waitFor("http://localhost:4173/");
+
+  const home = await fetch("http://localhost:4173/");
+  if (home.status !== 200) throw new Error(`Home status ${home.status}`);
+  const html = await home.text();
+  if (!html.includes("FastScript")) throw new Error("Home SSR did not include FastScript text");
+
+  const api = await fetch("http://localhost:4173/api/hello");
+  if (api.status !== 200) throw new Error(`API status ${api.status}`);
+  const apiJson = await api.json();
+  if (!apiJson.ok) throw new Error("API JSON did not return ok=true");
+
+  const privateRes = await fetch("http://localhost:4173/private", { redirect: "manual" });
+  if (!(privateRes.status === 302 || privateRes.status === 307)) {
+    throw new Error(`Expected redirect on /private, got ${privateRes.status}`);
+  }
+
+  const login = await fetch("http://localhost:4173/api/auth", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({}),
+    redirect: "manual",
+  });
+  if (login.status !== 200) throw new Error(`Auth login failed: ${login.status}`);
+  const setCookie = login.headers.get("set-cookie");
+  if (!setCookie || !setCookie.includes("fs_session=")) throw new Error("Missing fs_session cookie on login");
+
+  const bad = await fetch("http://localhost:4173/api/auth", {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: "{bad",
+  });
+  if (bad.status !== 400) throw new Error(`Expected 400 on invalid JSON, got ${bad.status}`);
+
+  const upload = await fetch("http://localhost:4173/api/upload", {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify({ key: "smoke/one.txt", content: "hello" }),
+  });
+  if (upload.status !== 200) throw new Error(`Upload failed: ${upload.status}`);
+  const up = await upload.json();
+  const blob = await fetch(`http://localhost:4173${up.url}`);
+  if (blob.status !== 200) throw new Error(`Uploaded blob fetch failed: ${blob.status}`);
+
+  console.log("smoke-dev pass: SSR, API, middleware redirect, auth cookie, validation, upload");
+} finally {
+  proc.kill("SIGTERM");
+  await sleep(400);
+}

package/scripts/smoke-start.mjs

@@ -0,0 +1,41 @@
+import { spawn } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+
+async function waitFor(url, ms = 20000) {
+  const start = Date.now();
+  while (Date.now() - start < ms) {
+    try {
+      const r = await fetch(url);
+      if (r.status >= 200) return;
+    } catch {}
+    await sleep(300);
+  }
+  throw new Error(`Timeout waiting for ${url}`);
+}
+
+const build = spawn(process.execPath, ["./src/cli.mjs", "build"], { cwd: process.cwd(), stdio: "inherit" });
+await new Promise((resolve, reject) => {
+  build.on("exit", (code) => (code === 0 ? resolve() : reject(new Error(`build failed: ${code}`))));
+});
+
+const proc = spawn(process.execPath, ["./src/cli.mjs", "start"], {
+  cwd: process.cwd(),
+  stdio: ["ignore", "pipe", "pipe"],
+  env: { ...process.env, PORT: "4173", NODE_ENV: "production" },
+});
+
+try {
+  await waitFor("http://localhost:4173/");
+  const home = await fetch("http://localhost:4173/");
+  if (home.status !== 200) throw new Error(`start home status ${home.status}`);
+  const reqId = home.headers.get("x-request-id");
+  if (!reqId) throw new Error("missing x-request-id header");
+
+  const api = await fetch("http://localhost:4173/api/hello", { headers: { accept: "application/json" } });
+  if (api.status !== 200) throw new Error(`start api status ${api.status}`);
+
+  console.log("smoke-start pass: production adapter serving SSR/API with request IDs");
+} finally {
+  proc.kill("SIGTERM");
+  await sleep(300);
+}

package/scripts/test-auth.mjs

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import { rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { createSessionManager, parseCookies, serializeCookie } from "../src/auth.mjs";
+
+const dir = resolve('.tmp-auth-tests');
+rmSync(dir, { recursive: true, force: true });
+
+const sm = createSessionManager({ dir, cookieName: 't' });
+const token = sm.create({ id: 'u1' }, 60);
+assert.ok(token.split('.').length === 3);
+assert.equal(sm.read(token).user.id, 'u1');
+
+const rotated = sm.rotate(token, 60);
+assert.ok(rotated);
+assert.equal(sm.read(token), null);
+assert.equal(sm.read(rotated).user.id, 'u1');
+
+sm.delete(rotated);
+assert.equal(sm.read(rotated), null);
+
+const c = serializeCookie('a', 'b', { path: '/', maxAge: 10, httpOnly: true });
+assert.ok(c.includes('a=b'));
+assert.equal(parseCookies('a=b; x=y').x, 'y');
+
+console.log('test-auth pass');

package/scripts/test-db.mjs

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import { rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { createFileDatabase } from "../src/db.mjs";
+
+const dir = resolve('.tmp-db-tests');
+rmSync(dir, { recursive: true, force: true });
+
+const db = createFileDatabase({ dir, name: 'test' });
+const users = db.collection('users');
+users.set('u1', { id: 'u1', role: 'admin', active: true });
+users.upsert('u2', () => ({ id: 'u2', role: 'user', active: false }));
+
+assert.equal(users.get('u1').role, 'admin');
+assert.equal(users.first((u) => u.id === 'u2').id, 'u2');
+assert.equal(users.where({ role: 'admin' }).length, 1);
+assert.equal(db.where('users', { active: false }).length, 1);
+
+let rolledBack = false;
+try {
+  db.transaction((tx) => {
+    tx.collection('users').set('u3', { id: 'u3' });
+    throw new Error('boom');
+  });
+} catch {
+  rolledBack = true;
+}
+assert.equal(rolledBack, true);
+assert.equal(users.get('u3'), null);
+
+console.log('test-db pass');

package/scripts/test-jobs.mjs

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import { rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { createJobQueue } from "../src/jobs.mjs";
+
+const dir = resolve('.tmp-jobs-tests');
+rmSync(dir, { recursive: true, force: true });
+const q = createJobQueue({ dir });
+const job = q.enqueue('a', { n: 1 }, { delayMs: 0, maxAttempts: 2, backoffMs: 1 });
+assert.equal(q.peekReady(10).length >= 1, true);
+q.fail(job);
+assert.equal(q.list().length, 1);
+q.fail(job);
+assert.equal(q.list().length, 0);
+console.log('test-jobs pass');

package/scripts/test-middleware.mjs

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { composeMiddleware } from "../src/middleware.mjs";
+
+const calls = [];
+const run = composeMiddleware([
+  async (ctx, next) => {
+    calls.push("m1:before");
+    ctx.x = 1;
+    const r = await next();
+    calls.push("m1:after");
+    return r;
+  },
+  async (ctx, next) => {
+    calls.push("m2:before");
+    ctx.y = ctx.x + 1;
+    const r = await next();
+    calls.push("m2:after");
+    return r;
+  },
+]);
+
+const result = await run({}, async () => {
+  calls.push("handler");
+  return { ok: true };
+});
+
+assert.equal(result.ok, true);
+assert.deepEqual(calls, ["m1:before", "m2:before", "handler", "m2:after", "m1:after"]);
+
+const short = composeMiddleware([
+  async () => ({ status: 401 }),
+  async () => ({ status: 200 }),
+]);
+const shortRes = await short({}, async () => ({ status: 204 }));
+assert.equal(shortRes.status, 401);
+
+console.log("test-middleware pass");

package/scripts/test-roundtrip.mjs

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { cpSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, existsSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { runMigrate } from "../src/migrate.mjs";
+import { runExport } from "../src/export.mjs";
+
+const root = resolve('.tmp-roundtrip');
+const pages = join(root, 'pages');
+rmSync(root, { recursive: true, force: true });
+mkdirSync(pages, { recursive: true });
+
+writeFileSync(join(pages, 'index.ts'), `
+import type { X } from './types'
+state n = 1
+function add(a: number, b: number): number { return a + b }
+export default function Home(){ return '<h1>' + String(add(n,2)) + '</h1>' }
+`, 'utf8');
+
+await runMigrate(root);
+assert.equal(existsSync(join(pages, 'index.fs')), true);
+assert.equal(existsSync(join(pages, 'index.ts')), false);
+
+const appDir = resolve('app');
+const restoreDir = mkdtempSync(join(tmpdir(), 'fs-app-backup-'));
+const backupApp = join(restoreDir, 'app');
+
+if (existsSync(appDir)) renameSync(appDir, backupApp);
+
+try {
+  mkdirSync(join(appDir, 'pages'), { recursive: true });
+  writeFileSync(join(appDir, 'pages', 'index.fs'), readFileSync(join(pages, 'index.fs'), 'utf8'), 'utf8');
+
+  await runExport(['--to', 'js', '--out', '.tmp-export-js']);
+  await runExport(['--to', 'ts', '--out', '.tmp-export-ts']);
+  assert.equal(existsSync(resolve('.tmp-export-js/pages/index.js')), true);
+  assert.equal(existsSync(resolve('.tmp-export-ts/pages/index.ts')), true);
+} finally {
+  rmSync(appDir, { recursive: true, force: true });
+  if (existsSync(backupApp)) renameSync(backupApp, appDir);
+  rmSync(restoreDir, { recursive: true, force: true });
+}
+
+console.log('test-roundtrip pass');

package/scripts/test-validation.mjs

@@ -0,0 +1,17 @@
+import assert from "node:assert/strict";
+import { validateShape } from "../src/validation.mjs";
+
+const q = validateShape({ page: "int", search: "string?" }, { page: "2" }, "query");
+assert.equal(q.value.page, 2);
+assert.equal(q.value.search, undefined);
+
+let failed = false;
+try {
+  validateShape({ page: "int" }, { page: "x" }, "query");
+} catch (e) {
+  failed = true;
+  assert.equal(e.status, 400);
+}
+assert.equal(failed, true);
+
+console.log("test-validation pass");

package/scripts/test-webhook-storage.mjs

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import { rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { signPayload, verifySignature, isReplay } from "../src/webhook.mjs";
+import { createLocalStorage } from "../src/storage.mjs";
+
+const payload = Buffer.from('{"ok":true}');
+const secret = 'topsecret';
+const sig = signPayload(payload, secret);
+assert.equal(verifySignature(payload, sig, secret), true);
+assert.equal(verifySignature(payload, sig, 'bad'), false);
+assert.equal(isReplay(Math.floor(Date.now() / 1000), 300), false);
+
+const dir = resolve('.tmp-storage-tests');
+rmSync(dir, { recursive: true, force: true });
+const store = createLocalStorage({ dir });
+store.put('a/b.txt', Buffer.from('hello'));
+assert.equal(String(store.get('a/b.txt')), 'hello');
+store.delete('a/b.txt');
+assert.equal(store.get('a/b.txt'), null);
+
+console.log('test-webhook-storage pass');