fastscript 1.0.0 → 2.0.0

package/src/build.mjs

@@ -1,234 +1 @@
-import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync, copyFileSync } from "node:fs";
-import { dirname, extname, join, relative, resolve } from "node:path";
-import esbuild from "esbuild";
-import {
-  createFastScriptDiagnosticError,
-  normalizeFastScriptWithTelemetry,
-} from "./fs-normalize.mjs";
-
-const APP_DIR = resolve("app");
-const PAGES_DIR = join(APP_DIR, "pages");
-const API_DIR = join(APP_DIR, "api");
-const DIST_DIR = resolve("dist");
-
-function walk(dir) {
-  const out = [];
-  if (!existsSync(dir)) return out;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...walk(full));
-    else out.push(full);
-  }
-  return out;
-}
-
-function fsLoaderPlugin() {
-  return {
-    name: "fastscript-fs-loader",
-    setup(build) {
-      build.onLoad({ filter: /\.fs$/ }, async (args) => {
-        const { readFile } = await import("node:fs/promises");
-        const raw = await readFile(args.path, "utf8");
-        const result = normalizeFastScriptWithTelemetry(raw, { filename: args.path, strict: false });
-        const hardErrors = result.diagnostics.filter((diag) => diag.severity === "error");
-        if (hardErrors.length > 0) {
-          throw createFastScriptDiagnosticError(hardErrors, { filename: args.path });
-        }
-        if (process.env.FASTSCRIPT_DEBUG_NORMALIZE === "1") {
-          console.log(
-            `normalize ${args.path} lines=${result.stats.lineCount} ms=${result.stats.durationMs.toFixed(2)} rx=${result.stats.reactiveToLet} st=${result.stats.stateToLet} fn=${result.stats.fnToFunction}`,
-          );
-        }
-        return {
-          contents: result.code,
-          loader: "js",
-        };
-      });
-    },
-  };
-}
-
-function routeFromPageFile(file) {
-  const rel = relative(PAGES_DIR, file).replace(/\\/g, "/").replace(/\.(js|fs)$/, "");
-  if (rel === "index") return "/";
-  const segs = rel.split("/").filter(Boolean);
-  if (segs.at(-1) === "index") segs.pop();
-  return "/" + segs.map((s) => (s.startsWith("[") && s.endsWith("]") ? `:${s.slice(1, -1)}` : s)).join("/");
-}
-
-function routeFromApiFile(file) {
-  const rel = relative(API_DIR, file).replace(/\\/g, "/").replace(/\.(js|fs)$/, "");
-  const segs = rel.split("/").filter(Boolean);
-  if (segs.at(-1) === "index") segs.pop();
-  return "/api/" + segs.join("/");
-}
-
-async function compileFile(file, out, platform) {
-  mkdirSync(dirname(out), { recursive: true });
-  await esbuild.build({
-    entryPoints: [file],
-    outfile: out,
-    bundle: true,
-    format: "esm",
-    platform,
-    sourcemap: true,
-    minify: platform === "browser",
-    logLevel: "silent",
-    resolveExtensions: [".fs", ".js", ".mjs", ".cjs", ".json"],
-    plugins: [fsLoaderPlugin()],
-    loader: { ".fs": "js" },
-  });
-}
-
-export async function runBuild() {
-  if (!existsSync(PAGES_DIR)) throw new Error("Missing app/pages directory. Run: fastscript create app");
-
-  rmSync(DIST_DIR, { recursive: true, force: true });
-  mkdirSync(DIST_DIR, { recursive: true });
-
-  const manifest = { routes: [], apiRoutes: [], layout: null, notFound: null, middleware: null };
-  const pageFiles = walk(PAGES_DIR).filter((f) => [".js", ".fs"].includes(extname(f)));
-
-  for (const file of pageFiles) {
-    const rel = relative(APP_DIR, file).replace(/\\/g, "/");
-    const relModule = rel.replace(/\.fs$/, ".js");
-    const relFromPages = relative(PAGES_DIR, file).replace(/\\/g, "/").replace(/\.(js|fs)$/, "");
-    const out = join(DIST_DIR, relModule);
-
-    await compileFile(file, out, "browser");
-
-    if (relFromPages === "_layout") manifest.layout = `./${relModule}`;
-    else if (relFromPages === "404") manifest.notFound = `./${relModule}`;
-    else if (!relFromPages.startsWith("_")) manifest.routes.push({ path: routeFromPageFile(file), module: `./${relModule}` });
-  }
-
-  if (existsSync(API_DIR)) {
-    const apiFiles = walk(API_DIR).filter((f) => [".js", ".fs"].includes(extname(f)));
-    for (const file of apiFiles) {
-      const rel = relative(APP_DIR, file).replace(/\\/g, "/");
-      const relModule = rel.replace(/\.fs$/, ".js");
-      const out = join(DIST_DIR, relModule);
-      await compileFile(file, out, "node");
-      manifest.apiRoutes.push({ path: routeFromApiFile(file), module: `./${relModule}` });
-    }
-  }
-
-  const middlewareSource = [join(APP_DIR, "middleware.fs"), join(APP_DIR, "middleware.js")].find((p) => existsSync(p));
-  if (middlewareSource) {
-    const rel = relative(APP_DIR, middlewareSource).replace(/\\/g, "/").replace(/\.fs$/, ".js");
-    const out = join(DIST_DIR, rel);
-    await compileFile(middlewareSource, out, "node");
-    manifest.middleware = `./${rel}`;
-  }
-
-  const stylesSrc = join(APP_DIR, "styles.css");
-  if (existsSync(stylesSrc)) copyFileSync(stylesSrc, join(DIST_DIR, "styles.css"));
-
-  writeFileSync(join(DIST_DIR, "fastscript-manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
-  writeFileSync(join(DIST_DIR, "router.js"), buildRouterRuntime(), "utf8");
-  writeFileSync(join(DIST_DIR, "index.html"), buildIndexHtml(existsSync(stylesSrc)), "utf8");
-
-  console.log(`built FastScript app with ${manifest.routes.length} page route(s) and ${manifest.apiRoutes.length} api route(s)`);
-}
-
-function buildIndexHtml(hasStyles) {
-  return `<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>FastScript</title>
-    ${hasStyles ? '<link rel="stylesheet" href="/styles.css" />' : ""}
-  </head>
-  <body>
-    <div id="app"></div>
-    <script type="module" src="/router.js"></script>
-  </body>
-</html>`;
-}
-
-function buildRouterRuntime() {
-  return `
-const app = document.getElementById("app");
-const manifest = await fetch("/fastscript-manifest.json").then((r) => r.json());
-
-function match(routePath, pathname) {
-  const a = routePath.split("/").filter(Boolean);
-  const b = pathname.split("/").filter(Boolean);
-  if (a.length !== b.length) return null;
-  const params = {};
-  for (let i = 0; i < a.length; i += 1) {
-    if (a[i].startsWith(":")) params[a[i].slice(1)] = b[i];
-    else if (a[i] !== b[i]) return null;
-  }
-  return params;
-}
-
-function findRoute(pathname) {
-  for (const route of manifest.routes) {
-    const params = match(route.path, pathname);
-    if (params) return { route, params };
-  }
-  return null;
-}
-
-async function hydrate(mod, ctx) {
-  if (typeof mod.hydrate === "function") {
-    await mod.hydrate({ ...ctx, root: app });
-  }
-}
-
-async function render(pathname, force = false) {
-  const path = pathname || "/";
-  const ssr = globalThis.__FASTSCRIPT_SSR;
-  const initialHit = ssr && ssr.pathname === path;
-
-  const matched = findRoute(path);
-  let mod = null;
-  let params = {};
-  let data = {};
-  let html = "";
-
-  if (matched) {
-    params = matched.params;
-    mod = await import(matched.route.module);
-  }
-
-  if (initialHit && !force) {
-    html = app.innerHTML;
-    if (ssr?.data) data = ssr.data;
-  } else if (!matched && manifest.notFound) {
-    const nfMod = await import(manifest.notFound);
-    html = (nfMod.default ? nfMod.default({ pathname: path }) : "<h1>404</h1>") || "";
-  } else if (matched) {
-    if (typeof mod.load === "function") data = (await mod.load({ params, pathname: path })) || {};
-    html = (mod.default ? mod.default({ ...data, params, pathname: path }) : "") || "";
-    if (manifest.layout) {
-      const layout = await import(manifest.layout);
-      html = layout.default ? layout.default({ content: html, pathname: path }) : html;
-    }
-    app.innerHTML = html;
-  }
-
-  bindLinks();
-  if (mod) await hydrate(mod, { pathname: path, params, data });
-  globalThis.__FASTSCRIPT_SSR = null;
-}
-
-function bindLinks() {
-  for (const a of app.querySelectorAll('a[href^="/"]')) {
-    if (a.dataset.fsBound === "1") continue;
-    a.dataset.fsBound = "1";
-    a.addEventListener("click", (e) => {
-      e.preventDefault();
-      const href = a.getAttribute("href");
-      history.pushState({}, "", href);
-      render(location.pathname, true);
-    });
-  }
-}
-
-window.addEventListener("popstate", () => render(location.pathname, true));
-render(location.pathname, false);
-`;
-}
+export * from "@fastscript/core-private/build";

package/src/cache.mjs

@@ -1,23 +1,80 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 
+function now() {
+  return Date.now();
+}
+
+function normalizeTags(tags) {
+  return [...new Set((Array.isArray(tags) ? tags : []).map((tag) => String(tag).trim()).filter(Boolean))];
+}
+
+function expired(row) {
+  return Boolean(row && row.exp && row.exp < now());
+}
+
 export function createMemoryCache() {
-  const m = new Map();
+  const rows = new Map();
+  const tagIndex = new Map();
+
+  function attachTags(key, tags) {
+    for (const tag of normalizeTags(tags)) {
+      if (!tagIndex.has(tag)) tagIndex.set(tag, new Set());
+      tagIndex.get(tag).add(key);
+    }
+  }
+
+  function detachTags(key, tags) {
+    for (const tag of normalizeTags(tags)) {
+      const set = tagIndex.get(tag);
+      if (!set) continue;
+      set.delete(key);
+      if (set.size === 0) tagIndex.delete(tag);
+    }
+  }
+
   return {
     async get(key) {
-      const row = m.get(key);
+      const row = rows.get(key);
       if (!row) return null;
-      if (row.exp && row.exp < Date.now()) {
-        m.delete(key);
+      if (expired(row)) {
+        detachTags(key, row.tags);
+        rows.delete(key);
         return null;
       }
       return row.value;
     },
     async set(key, value, ttlMs = 0) {
-      m.set(key, { value, exp: ttlMs ? Date.now() + ttlMs : 0 });
+      const prev = rows.get(key);
+      if (prev) detachTags(key, prev.tags);
+      rows.set(key, { value, exp: ttlMs ? now() + ttlMs : 0, tags: [] });
+    },
+    async setWithTags(key, value, { ttlMs = 0, tags = [] } = {}) {
+      const prev = rows.get(key);
+      if (prev) detachTags(key, prev.tags);
+      const normalizedTags = normalizeTags(tags);
+      rows.set(key, { value, exp: ttlMs ? now() + ttlMs : 0, tags: normalizedTags });
+      attachTags(key, normalizedTags);
+    },
+    async del(key) {
+      const prev = rows.get(key);
+      if (prev) detachTags(key, prev.tags);
+      rows.delete(key);
+    },
+    async invalidateTag(tag) {
+      const keys = [...(tagIndex.get(tag) || [])];
+      for (const key of keys) {
+        const row = rows.get(key);
+        if (row) detachTags(key, row.tags);
+        rows.delete(key);
+      }
+      tagIndex.delete(tag);
+      return keys.length;
+    },
+    async clear() {
+      rows.clear();
+      tagIndex.clear();
     },
-    async del(key) { m.delete(key); },
-    async clear() { m.clear(); },
   };
 }
 
@@ -25,34 +82,167 @@ export function createFileCache({ dir = ".fastscript/cache" } = {}) {
   const root = resolve(dir);
   mkdirSync(root, { recursive: true });
   const p = (key) => join(root, `${encodeURIComponent(key)}.json`);
+  const tagsFile = join(root, "_tags.json");
+
+  function readTags() {
+    if (!existsSync(tagsFile)) return {};
+    try {
+      return JSON.parse(readFileSync(tagsFile, "utf8")) || {};
+    } catch {
+      return {};
+    }
+  }
+
+  function writeTags(index) {
+    writeFileSync(tagsFile, JSON.stringify(index, null, 2), "utf8");
+  }
+
+  function detach(key) {
+    const index = readTags();
+    let changed = false;
+    for (const [tag, keys] of Object.entries(index)) {
+      const next = (Array.isArray(keys) ? keys : []).filter((item) => item !== key);
+      if (next.length !== keys.length) changed = true;
+      if (next.length) index[tag] = next;
+      else delete index[tag];
+    }
+    if (changed) writeTags(index);
+  }
+
+  function attach(key, tags) {
+    const normalized = normalizeTags(tags);
+    if (!normalized.length) return;
+    const index = readTags();
+    for (const tag of normalized) {
+      const set = new Set(Array.isArray(index[tag]) ? index[tag] : []);
+      set.add(key);
+      index[tag] = [...set];
+    }
+    writeTags(index);
+  }
+
   return {
     async get(key) {
       const file = p(key);
       if (!existsSync(file)) return null;
       const row = JSON.parse(readFileSync(file, "utf8"));
-      if (row.exp && row.exp < Date.now()) { rmSync(file, { force: true }); return null; }
+      if (expired(row)) {
+        rmSync(file, { force: true });
+        detach(key);
+        return null;
+      }
       return row.value;
     },
     async set(key, value, ttlMs = 0) {
-      writeFileSync(p(key), JSON.stringify({ value, exp: ttlMs ? Date.now() + ttlMs : 0 }), "utf8");
+      writeFileSync(p(key), JSON.stringify({ value, exp: ttlMs ? now() + ttlMs : 0, tags: [] }), "utf8");
+      detach(key);
+    },
+    async setWithTags(key, value, { ttlMs = 0, tags = [] } = {}) {
+      const normalized = normalizeTags(tags);
+      writeFileSync(p(key), JSON.stringify({ value, exp: ttlMs ? now() + ttlMs : 0, tags: normalized }), "utf8");
+      detach(key);
+      attach(key, normalized);
+    },
+    async del(key) {
+      rmSync(p(key), { force: true });
+      detach(key);
+    },
+    async invalidateTag(tag) {
+      const index = readTags();
+      const keys = Array.isArray(index[tag]) ? index[tag] : [];
+      for (const key of keys) rmSync(p(key), { force: true });
+      delete index[tag];
+      writeTags(index);
+      return keys.length;
+    },
+    async clear() {
+      rmSync(root, { recursive: true, force: true });
+      mkdirSync(root, { recursive: true });
     },
-    async del(key) { rmSync(p(key), { force: true }); },
-    async clear() { rmSync(root, { recursive: true, force: true }); mkdirSync(root, { recursive: true }); },
   };
 }
 
-export async function createRedisCache({ url = process.env.REDIS_URL } = {}) {
+function stringifyValue(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+
+function parseValue(value) {
+  if (value === null || value === undefined) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+export async function createRedisCache({ url = process.env.REDIS_URL, prefix = "fastscript:cache" } = {}) {
   const mod = await import("redis");
   const client = mod.createClient({ url });
   await client.connect();
+
+  function rowKey(key) {
+    return `${prefix}:row:${key}`;
+  }
+  function tagKey(tag) {
+    return `${prefix}:tag:${tag}`;
+  }
+
+  async function detachFromTags(key) {
+    const tags = await client.sMembers(`${prefix}:rowtags:${key}`);
+    if (!tags.length) return;
+    for (const tag of tags) await client.sRem(tagKey(tag), key);
+    await client.del(`${prefix}:rowtags:${key}`);
+  }
+
   return {
-    async get(key) { return client.get(key); },
+    async get(key) {
+      const raw = await client.get(rowKey(key));
+      if (raw === null) return null;
+      const row = parseValue(raw);
+      if (!row || typeof row !== "object") return row;
+      if (expired(row)) {
+        await this.del(key);
+        return null;
+      }
+      return row.value;
+    },
     async set(key, value, ttlMs = 0) {
-      if (ttlMs > 0) await client.set(key, value, { PX: ttlMs });
-      else await client.set(key, value);
+      await detachFromTags(key);
+      const row = stringifyValue({ value, exp: ttlMs ? now() + ttlMs : 0, tags: [] });
+      if (ttlMs > 0) await client.set(rowKey(key), row, { PX: ttlMs });
+      else await client.set(rowKey(key), row);
+    },
+    async setWithTags(key, value, { ttlMs = 0, tags = [] } = {}) {
+      await detachFromTags(key);
+      const normalized = normalizeTags(tags);
+      const row = stringifyValue({ value, exp: ttlMs ? now() + ttlMs : 0, tags: normalized });
+      if (ttlMs > 0) await client.set(rowKey(key), row, { PX: ttlMs });
+      else await client.set(rowKey(key), row);
+      for (const tag of normalized) await client.sAdd(tagKey(tag), key);
+      if (normalized.length) await client.sAdd(`${prefix}:rowtags:${key}`, ...normalized);
+    },
+    async del(key) {
+      await detachFromTags(key);
+      await client.del(rowKey(key));
+    },
+    async invalidateTag(tag) {
+      const keys = await client.sMembers(tagKey(tag));
+      for (const key of keys) await this.del(key);
+      await client.del(tagKey(tag));
+      return keys.length;
+    },
+    async clear() {
+      const cursor = "0";
+      let next = cursor;
+      do {
+        const data = await client.scan(next, { MATCH: `${prefix}:*`, COUNT: 200 });
+        next = data.cursor;
+        if (data.keys && data.keys.length) await client.del(data.keys);
+      } while (next !== "0");
+    },
+    async close() {
+      await client.quit();
     },
-    async del(key) { await client.del(key); },
-    async clear() { await client.flushDb(); },
-    async close() { await client.quit(); },
   };
-}
+}

package/src/cli.mjs

@@ -8,17 +8,23 @@ import { runBench } from "./bench.mjs";
 import { runExport } from "./export.mjs";
 import { runCompat } from "./compat.mjs";
 import { runValidate } from "./validate.mjs";
-import { runDbMigrate, runDbSeed } from "./db-cli.mjs";
+import { runDbMigrate, runDbRollback, runDbSeed } from "./db-cli.mjs";
 import { runStart } from "./start.mjs";
 import { runDeploy } from "./deploy.mjs";
 import { runWorkerCommand } from "./worker.mjs";
+import { runTypeCheck } from "./typecheck.mjs";
+import { runFormat } from "./fs-formatter.mjs";
+import { runLint } from "./fs-linter.mjs";
+import { runMigrationWizard } from "./migration-wizard.mjs";
 
 const [, , command, ...args] = process.argv;
 
 async function main() {
   switch (command) {
     case "create":
-      await createApp(args[0] ?? "app");
+      await createApp(args[0] ?? "app", {
+        template: args.includes("--template") ? args[args.indexOf("--template") + 1] || "default" : "default",
+      });
       break;
     case "dev":
       await runDev();
@@ -27,7 +33,10 @@ async function main() {
       await runStart();
       break;
     case "build":
-      await runBuild();
+      await runBuild({ mode: args.includes("--mode") ? args[args.indexOf("--mode") + 1] || "build" : "build" });
+      break;
+    case "ssg":
+      await runBuild({ mode: "ssg" });
       break;
     case "check":
       await runCheck();
@@ -35,6 +44,9 @@ async function main() {
     case "migrate":
       await runMigrate(args[0] ?? "app/pages");
       break;
+    case "wizard:migrate":
+      await runMigrationWizard(args);
+      break;
     case "bench":
       await runBench();
       break;
@@ -47,21 +59,33 @@ async function main() {
     case "validate":
       await runValidate();
       break;
+    case "typecheck":
+      await runTypeCheck(args);
+      break;
+    case "format":
+      await runFormat(args);
+      break;
+    case "lint":
+      await runLint(args);
+      break;
     case "db:migrate":
       await runDbMigrate();
       break;
     case "db:seed":
       await runDbSeed();
       break;
+    case "db:rollback":
+      await runDbRollback(args);
+      break;
     case "deploy":
       await runDeploy(args);
       break;
     case "worker":
-      await runWorkerCommand();
+      await runWorkerCommand(args);
       break;
     default:
       console.log("FastScript CLI");
-      console.log("Commands: create, dev, start, build, check, migrate, bench, export, compat, validate, db:migrate, db:seed, deploy, worker");
+      console.log("Commands: create, dev, start, build, ssg, check, migrate, wizard:migrate, bench, export, compat, validate, typecheck, format, lint, db:migrate, db:seed, db:rollback, deploy, worker");
   }
 }
 

package/src/compat.mjs

@@ -1,26 +1,24 @@
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import esbuild from "esbuild";
-import {
-  createFastScriptDiagnosticError,
-  normalizeFastScriptWithTelemetry,
-} from "./fs-normalize.mjs";
+import { normalizeFastScript } from "./fs-normalize.mjs";
+import { assertFastScript } from "./fs-diagnostics.mjs";
 
 const TMP_DIR = resolve(".fastscript-tmp-compat");
 
 function fsLoaderPlugin() {
+  const compilerMode = (process.env.FASTSCRIPT_COMPILER_MODE || "strict").toLowerCase() === "lenient" ? "lenient" : "strict";
   return {
     name: "fastscript-fs-loader",
     setup(build) {
       build.onLoad({ filter: /\.fs$/ }, async (args) => {
         const { readFile } = await import("node:fs/promises");
         const raw = await readFile(args.path, "utf8");
-        const result = normalizeFastScriptWithTelemetry(raw, { filename: args.path, strict: false });
-        const hardErrors = result.diagnostics.filter((diag) => diag.severity === "error");
-        if (hardErrors.length > 0) {
-          throw createFastScriptDiagnosticError(hardErrors, { filename: args.path });
-        }
-        return { contents: result.code, loader: "js" };
+        assertFastScript(raw, { file: args.path, mode: compilerMode });
+        return {
+          contents: normalizeFastScript(raw, { file: args.path, mode: compilerMode, sourceMap: "inline" }),
+          loader: "js",
+        };
       });
     },
   };