fastscript 1.0.0 → 3.0.0

package/node_modules/@fastscript/core-private/src/cache.mjs

@@ -0,0 +1,248 @@
+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 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 = rows.get(key);
+      if (!row) return null;
+      if (expired(row)) {
+        detachTags(key, row.tags);
+        rows.delete(key);
+        return null;
+      }
+      return row.value;
+    },
+    async set(key, value, 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();
+    },
+  };
+}
+
+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 (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 ? 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 });
+    },
+  };
+}
+
+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) {
+      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) {
+      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();
+    },
+  };
+}

package/node_modules/@fastscript/core-private/src/check.mjs

@@ -0,0 +1,22 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+export async function runCheck() {
+  const indexExists = existsSync(resolve("app/pages/index.fs")) || existsSync(resolve("app/pages/index.js"));
+  const layoutExists = existsSync(resolve("app/pages/_layout.fs")) || existsSync(resolve("app/pages/_layout.js"));
+
+  const required = [
+    resolve("app"),
+    resolve("app/pages"),
+  ];
+
+  const missing = required.filter((path) => !existsSync(path));
+  if (!indexExists) missing.push("app/pages/index.fs (or index.js)");
+  if (!layoutExists) missing.push("app/pages/_layout.fs (or _layout.js)");
+
+  if (missing.length > 0) {
+    throw new Error(`Missing required FastScript files:\n${missing.join("\n")}`);
+  }
+
+  console.log("check passed: FastScript app structure is valid");
+}

package/node_modules/@fastscript/core-private/src/cli.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { createApp } from "./create.mjs";
+import { runDev } from "./dev.mjs";
+import { runBuild } from "./build.mjs";
+import { runCheck } from "./check.mjs";
+import { runMigrate } from "./migrate.mjs";
+import { runBench } from "./bench.mjs";
+import { runExport } from "./export.mjs";
+import { runCompat } from "./compat.mjs";
+import { runValidate } from "./validate.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", {
+        template: args.includes("--template") ? args[args.indexOf("--template") + 1] || "default" : "default",
+      });
+      break;
+    case "dev":
+      await runDev();
+      break;
+    case "start":
+      await runStart();
+      break;
+    case "build":
+      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();
+      break;
+    case "migrate":
+      await runMigrate(args[0] ?? "app/pages");
+      break;
+    case "wizard:migrate":
+      await runMigrationWizard(args);
+      break;
+    case "bench":
+      await runBench();
+      break;
+    case "export":
+      await runExport(args);
+      break;
+    case "compat":
+      await runCompat();
+      break;
+    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(args);
+      break;
+    default:
+      console.log("FastScript CLI");
+      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");
+  }
+}
+
+main().catch((error) => {
+  console.error("fastscript error:", error.message);
+  process.exit(1);
+});

package/node_modules/@fastscript/core-private/src/compat.mjs

@@ -0,0 +1,128 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import esbuild from "esbuild";
+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");
+        assertFastScript(raw, { file: args.path, mode: compilerMode });
+        return {
+          contents: normalizeFastScript(raw, { file: args.path, mode: compilerMode, sourceMap: "inline" }),
+          loader: "js",
+        };
+      });
+    },
+  };
+}
+
+async function bundle(entry) {
+  await esbuild.build({
+    entryPoints: [entry],
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    write: false,
+    logLevel: "silent",
+    plugins: [fsLoaderPlugin()],
+    loader: { ".fs": "js" },
+    resolveExtensions: [".fs", ".js", ".mjs", ".cjs", ".json"],
+  });
+}
+
+export async function runCompat() {
+  rmSync(TMP_DIR, { recursive: true, force: true });
+  mkdirSync(TMP_DIR, { recursive: true });
+
+  // CJS fixture
+  writeFileSync(
+    join(TMP_DIR, "cjs-lib.cjs"),
+    `module.exports = { answer: 42, greet(name){ return "hi " + name; } };`,
+    "utf8",
+  );
+
+  // ESM fixture
+  writeFileSync(
+    join(TMP_DIR, "esm-lib.js"),
+    `export const value = 7; export default function twice(n){ return n*2; }`,
+    "utf8",
+  );
+
+  // FS fixture using lenient syntax + mixed imports.
+  writeFileSync(
+    join(TMP_DIR, "entry.fs"),
+    `import cjs from "./cjs-lib.cjs"
+import twice, { value } from "./esm-lib.js"
+
+state name = "fastscript"
+fn run(n) {
+  return cjs.greet(name) + ":" + String(twice(n) + value + cjs.answer)
+}
+
+export default run
+`,
+    "utf8",
+  );
+
+  // JS fixture importing FS module.
+  writeFileSync(
+    join(TMP_DIR, "entry-js.js"),
+    `import run from "./entry.fs"; export default run(1);`,
+    "utf8",
+  );
+
+  // Dynamic import + JSON compatibility fixture.
+  writeFileSync(join(TMP_DIR, "data.json"), JSON.stringify({ ok: true, n: 3 }), "utf8");
+  writeFileSync(
+    join(TMP_DIR, "dynamic.js"),
+    `export async function getN(){ const mod = await import("./data.json"); return mod.default.n; }`,
+    "utf8",
+  );
+  writeFileSync(
+    join(TMP_DIR, "dynamic-entry.fs"),
+    `fn boot() { return "ok" }
+export async function run() {
+  const mod = await import("./dynamic.js");
+  return mod.getN();
+}
+export default boot
+`,
+    "utf8",
+  );
+
+  // TS-like migrated syntax fixture.
+  writeFileSync(
+    join(TMP_DIR, "ts-like.fs"),
+    `state total = 0
+fn add(n) { total = total + n; return total }
+export default add
+`,
+    "utf8",
+  );
+
+  const checks = [
+    { name: "fs-entry-bundle", entry: join(TMP_DIR, "entry.fs") },
+    { name: "js-imports-fs-bundle", entry: join(TMP_DIR, "entry-js.js") },
+    { name: "dynamic-json-import-bundle", entry: join(TMP_DIR, "dynamic-entry.fs") },
+    { name: "ts-like-fs-bundle", entry: join(TMP_DIR, "ts-like.fs") },
+  ];
+
+  for (const check of checks) {
+    try {
+      await bundle(check.entry);
+      console.log(`compat pass: ${check.name}`);
+    } catch (error) {
+      throw new Error(`compat fail: ${check.name}\n${error.message}`);
+    }
+  }
+
+  console.log("compat summary: core ESM/CJS/FS interop checks passed");
+}