fastscript 1.0.0 → 2.0.0

package/src/i18n.mjs

@@ -0,0 +1,25 @@
+export function getI18nConfig(env = process.env) {
+  const locales = String(env.I18N_LOCALES || "en").split(",").map((x) => x.trim()).filter(Boolean);
+  const defaultLocale = String(env.I18N_DEFAULT_LOCALE || locales[0] || "en").trim() || "en";
+  return { locales, defaultLocale };
+}
+
+export function resolveLocaleFromPath(pathname, config = getI18nConfig()) {
+  const parts = String(pathname || "/").split("/").filter(Boolean);
+  const first = parts[0];
+  if (first && config.locales.includes(first)) {
+    const nextPath = `/${parts.slice(1).join("/")}`;
+    return {
+      locale: first,
+      pathname: nextPath === "/" ? "/" : nextPath.replace(/\/+$/, "") || "/",
+      isLocalized: true,
+    };
+  }
+  return { locale: config.defaultLocale, pathname: pathname || "/", isLocalized: false };
+}
+
+export function withLocalePath(pathname, locale, config = getI18nConfig()) {
+  const normalized = String(pathname || "/").startsWith("/") ? String(pathname || "/") : `/${pathname}`;
+  if (!locale || locale === config.defaultLocale) return normalized;
+  return `/${locale}${normalized === "/" ? "" : normalized}`;
+}

package/src/jobs.mjs

@@ -1,28 +1,47 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
+import { importSourceModule } from "./module-loader.mjs";
+import { nextCronRun, normalizeScheduleEntry } from "./scheduler.mjs";
 
 function readJson(path, fallback) {
   if (!existsSync(path)) return fallback;
-  try { return JSON.parse(readFileSync(path, "utf8")); } catch { return fallback; }
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
 }
 
 function writeJson(path, value) {
   writeFileSync(path, JSON.stringify(value, null, 2), "utf8");
 }
 
-export function createJobQueue({ dir = ".fastscript" } = {}) {
+function createFileQueue({ dir = ".fastscript" } = {}) {
   const root = resolve(dir);
   mkdirSync(root, { recursive: true });
-  const path = join(root, "jobs.json");
-  const state = readJson(path, { jobs: [] });
+  const jobsPath = join(root, "jobs.json");
+  const deadPath = join(root, "jobs-dead-letter.json");
+  const state = readJson(jobsPath, { jobs: [] });
+  const dead = readJson(deadPath, { jobs: [] });
 
-  function persist() { writeJson(path, state); }
+  function persist() {
+    writeJson(jobsPath, state);
+  }
+  function persistDead() {
+    writeJson(deadPath, dead);
+  }
 
   return {
+    type: "file",
     enqueue(name, payload = {}, opts = {}) {
       const now = Date.now();
       const delayMs = opts.delayMs ?? 0;
+      const dedupeKey = opts.dedupeKey || null;
+      if (dedupeKey) {
+        const duplicate = state.jobs.find((j) => j.name === name && j.dedupeKey === dedupeKey);
+        if (duplicate) return duplicate;
+      }
       const job = {
         id: randomUUID(),
         name,
@@ -32,6 +51,9 @@ export function createJobQueue({ dir = ".fastscript" } = {}) {
         maxAttempts: opts.maxAttempts ?? 3,
         backoffMs: opts.backoffMs ?? 250,
         repeatEveryMs: opts.repeatEveryMs ?? 0,
+        cron: opts.cron || null,
+        timezone: opts.timezone || "UTC",
+        dedupeKey,
       };
       state.jobs.push(job);
       persist();
@@ -39,42 +61,219 @@ export function createJobQueue({ dir = ".fastscript" } = {}) {
     },
     peekReady(limit = 10) {
       const now = Date.now();
-      return state.jobs.filter((j) => j.runAt <= now).slice(0, limit);
+      return state.jobs.filter((job) => job.runAt <= now).slice(0, limit);
     },
     ack(id) {
-      state.jobs = state.jobs.filter((j) => j.id !== id);
+      state.jobs = state.jobs.filter((job) => job.id !== id);
       persist();
     },
-    fail(job) {
+    fail(job, error = null) {
       const idx = state.jobs.findIndex((j) => j.id === job.id);
       if (idx < 0) return;
       const current = state.jobs[idx];
       current.attempts += 1;
       if (current.attempts >= current.maxAttempts) {
+        dead.jobs.push({
+          ...current,
+          failedAt: Date.now(),
+          error: error ? String(error?.message || error) : null,
+        });
         state.jobs.splice(idx, 1);
+        persistDead();
       } else {
         current.runAt = Date.now() + current.backoffMs * current.attempts;
       }
       persist();
     },
+    deadLetter() {
+      return [...dead.jobs];
+    },
+    replayDeadLetter({ limit = 20, name = null } = {}) {
+      const out = [];
+      const keep = [];
+      for (const row of dead.jobs) {
+        if (out.length >= limit) {
+          keep.push(row);
+          continue;
+        }
+        if (name && row.name !== name) {
+          keep.push(row);
+          continue;
+        }
+        const replay = {
+          ...row,
+          id: randomUUID(),
+          attempts: 0,
+          runAt: Date.now(),
+        };
+        delete replay.failedAt;
+        delete replay.error;
+        state.jobs.push(replay);
+        out.push(replay);
+      }
+      dead.jobs = keep;
+      persist();
+      persistDead();
+      return out;
+    },
     list() {
       return [...state.jobs];
     },
   };
 }
 
+export async function createRedisJobQueue({
+  url = process.env.REDIS_URL,
+  prefix = "fastscript:queue",
+} = {}) {
+  const mod = await import("redis");
+  const client = mod.createClient({ url });
+  await client.connect();
+
+  const keys = {
+    ready: `${prefix}:ready`,
+    dead: `${prefix}:dead`,
+  };
+  const rowKey = (id) => `${prefix}:job:${id}`;
+  const dedupeKey = (name, key) => `${prefix}:dedupe:${name}:${key}`;
+
+  return {
+    type: "redis",
+    async enqueue(name, payload = {}, opts = {}) {
+      const id = randomUUID();
+      const runAt = Date.now() + (opts.delayMs ?? 0);
+      const row = {
+        id,
+        name,
+        payload,
+        runAt,
+        attempts: 0,
+        maxAttempts: opts.maxAttempts ?? 3,
+        backoffMs: opts.backoffMs ?? 250,
+        repeatEveryMs: opts.repeatEveryMs ?? 0,
+        cron: opts.cron || null,
+        timezone: opts.timezone || "UTC",
+        dedupeKey: opts.dedupeKey || null,
+      };
+      if (row.dedupeKey) {
+        const key = dedupeKey(name, row.dedupeKey);
+        const existing = await client.get(key);
+        if (existing) {
+          const existingJob = await client.get(rowKey(existing));
+          if (existingJob) return JSON.parse(existingJob);
+        }
+        await client.set(key, id);
+      }
+      await client.set(rowKey(id), JSON.stringify(row));
+      await client.zAdd(keys.ready, { score: runAt, value: id });
+      return row;
+    },
+    async peekReady(limit = 10) {
+      const ids = await client.zRangeByScore(keys.ready, 0, Date.now(), { LIMIT: { offset: 0, count: limit } });
+      const out = [];
+      for (const id of ids) {
+        const raw = await client.get(rowKey(id));
+        if (!raw) continue;
+        out.push(JSON.parse(raw));
+      }
+      return out;
+    },
+    async ack(id) {
+      const raw = await client.get(rowKey(id));
+      if (raw) {
+        const row = JSON.parse(raw);
+        if (row.dedupeKey) await client.del(dedupeKey(row.name, row.dedupeKey));
+      }
+      await client.zRem(keys.ready, id);
+      await client.del(rowKey(id));
+    },
+    async fail(job, error = null) {
+      const raw = await client.get(rowKey(job.id));
+      if (!raw) return;
+      const current = JSON.parse(raw);
+      current.attempts += 1;
+      if (current.attempts >= current.maxAttempts) {
+        current.failedAt = Date.now();
+        current.error = error ? String(error?.message || error) : null;
+        await client.rPush(keys.dead, JSON.stringify(current));
+        await this.ack(current.id);
+      } else {
+        current.runAt = Date.now() + current.backoffMs * current.attempts;
+        await client.set(rowKey(current.id), JSON.stringify(current));
+        await client.zAdd(keys.ready, { score: current.runAt, value: current.id });
+      }
+    },
+    async deadLetter() {
+      const rows = await client.lRange(keys.dead, 0, -1);
+      return rows.map((row) => JSON.parse(row));
+    },
+    async replayDeadLetter({ limit = 20, name = null } = {}) {
+      const rows = await this.deadLetter();
+      const picked = [];
+      const keep = [];
+      for (const row of rows) {
+        if (picked.length >= limit) {
+          keep.push(row);
+          continue;
+        }
+        if (name && row.name !== name) {
+          keep.push(row);
+          continue;
+        }
+        picked.push(row);
+      }
+      await client.del(keys.dead);
+      if (keep.length) await client.rPush(keys.dead, ...keep.map((row) => JSON.stringify(row)));
+      for (const row of picked) {
+        await this.enqueue(row.name, row.payload, {
+          delayMs: 0,
+          maxAttempts: row.maxAttempts,
+          backoffMs: row.backoffMs,
+          repeatEveryMs: row.repeatEveryMs,
+          cron: row.cron,
+          timezone: row.timezone,
+          dedupeKey: row.dedupeKey,
+        });
+      }
+      return picked;
+    },
+    async list() {
+      return this.peekReady(1000);
+    },
+    async close() {
+      await client.quit();
+    },
+  };
+}
+
+export function createJobQueue({ dir = ".fastscript" } = {}) {
+  return createFileQueue({ dir });
+}
+
+export async function createDistributedJobQueue({ dir = ".fastscript", driver = process.env.JOBS_DRIVER || "file" } = {}) {
+  const mode = String(driver).toLowerCase();
+  if (mode === "redis") {
+    try {
+      return await createRedisJobQueue();
+    } catch {
+      return createFileQueue({ dir });
+    }
+  }
+  return createFileQueue({ dir });
+}
+
 export async function loadJobHandlers({ root = process.cwd() } = {}) {
   const fs = await import("node:fs");
   const path = await import("node:path");
   const jobsDir = path.join(root, "app", "jobs");
   const handlers = new Map();
   if (!fs.existsSync(jobsDir)) return handlers;
-  const files = fs.readdirSync(jobsDir).filter((f) => /\.(js|mjs|cjs)$/.test(f));
+  const files = fs.readdirSync(jobsDir).filter((f) => /\.(fs|js|mjs|cjs)$/.test(f));
   for (const file of files) {
-    if (file === "schedules.js") continue;
-    const full = path.join(jobsDir, file).replace(/\\/g, "/");
-    const mod = await import(`${new URL(`file://${full}`).href}?t=${Date.now()}`);
-    const name = mod.name || file.replace(/\.(js|mjs|cjs)$/, "");
+    if (file === "schedules.js" || file === "schedules.fs") continue;
+    const full = path.join(jobsDir, file);
+    const mod = await importSourceModule(full, { platform: "node" });
+    const name = mod.name || file.replace(/\.(fs|js|mjs|cjs)$/, "");
     const handle = mod.handle || mod.default;
     if (typeof handle === "function") handlers.set(name, handle);
   }
@@ -84,44 +283,96 @@ export async function loadJobHandlers({ root = process.cwd() } = {}) {
 export async function loadSchedules({ root = process.cwd() } = {}) {
   const fs = await import("node:fs");
   const path = await import("node:path");
-  const file = path.join(root, "app", "jobs", "schedules.js");
+  const jsFile = path.join(root, "app", "jobs", "schedules.js");
+  const fsFile = path.join(root, "app", "jobs", "schedules.fs");
+  const file = fs.existsSync(fsFile) ? fsFile : jsFile;
   if (!fs.existsSync(file)) return [];
-  const mod = await import(`${new URL(`file://${file.replace(/\\/g, "/")}`).href}?t=${Date.now()}`);
-  return mod.schedules || mod.default || [];
+  const mod = await importSourceModule(file, { platform: "node" });
+  const schedules = mod.schedules || mod.default || [];
+  return (Array.isArray(schedules) ? schedules : []).map((row) => normalizeScheduleEntry(row)).filter(Boolean);
 }
 
-export async function runWorker({ dir = ".fastscript", pollMs = 350 } = {}) {
-  const queue = createJobQueue({ dir });
+function nextRunForJob(job) {
+  if (job.cron) {
+    const next = nextCronRun(job.cron, { timezone: job.timezone || "UTC" });
+    return next ? next.getTime() : null;
+  }
+  if (job.repeatEveryMs > 0) return Date.now() + job.repeatEveryMs;
+  return null;
+}
+
+export async function runWorker({ dir = ".fastscript", pollMs = 350, driver = process.env.JOBS_DRIVER || "file" } = {}) {
+  const queue = await createDistributedJobQueue({ dir, driver });
   const handlers = await loadJobHandlers();
   const schedules = await loadSchedules();
+  let inFlight = 0;
+  let stopping = false;
 
   for (const s of schedules) {
     if (!s || !s.name) continue;
-    const exists = queue.list().some((j) => j.name === s.name && j.runAt > Date.now());
-    if (!exists) queue.enqueue(s.name, s.payload || {}, { delayMs: s.everyMs ?? 1000, maxAttempts: s.maxAttempts ?? 3, repeatEveryMs: s.everyMs ?? 0 });
+    await queue.enqueue(s.name, s.payload || {}, {
+      delayMs: Math.max(0, (s.nextRunAt || Date.now()) - Date.now()),
+      maxAttempts: s.maxAttempts ?? 3,
+      repeatEveryMs: s.everyMs || 0,
+      cron: s.cron || null,
+      timezone: s.timezone || "UTC",
+      dedupeKey: s.dedupeKey || `schedule:${s.name}`,
+    });
   }
 
-  console.log(`worker started: handlers=${handlers.size}`);
+  console.log(`worker started: handlers=${handlers.size} driver=${driver}`);
   const timer = setInterval(async () => {
-    const jobs = queue.peekReady(20);
+    if (stopping) return;
+    const jobs = await queue.peekReady(20);
     for (const job of jobs) {
       const handle = handlers.get(job.name);
       if (!handle) {
-        queue.fail(job);
+        await queue.fail(job, "handler_not_found");
         continue;
       }
+      inFlight += 1;
       try {
         await handle(job.payload, { queue });
-        if (job.repeatEveryMs > 0) {
-          queue.enqueue(job.name, job.payload, { delayMs: job.repeatEveryMs, maxAttempts: job.maxAttempts, backoffMs: job.backoffMs, repeatEveryMs: job.repeatEveryMs });
+        const nextRun = nextRunForJob(job);
+        if (nextRun) {
+          await queue.enqueue(job.name, job.payload, {
+            delayMs: Math.max(0, nextRun - Date.now()),
+            maxAttempts: job.maxAttempts,
+            backoffMs: job.backoffMs,
+            repeatEveryMs: job.repeatEveryMs,
+            cron: job.cron,
+            timezone: job.timezone,
+            dedupeKey: job.dedupeKey || null,
+          });
         }
-        queue.ack(job.id);
-      } catch {
-        queue.fail(job);
+        await queue.ack(job.id);
+      } catch (error) {
+        await queue.fail(job, error);
+      } finally {
+        inFlight -= 1;
       }
     }
   }, pollMs);
 
-  process.on("SIGINT", () => { clearInterval(timer); process.exit(0); });
-  process.on("SIGTERM", () => { clearInterval(timer); process.exit(0); });
-}
+  async function shutdown() {
+    if (stopping) return;
+    stopping = true;
+    clearInterval(timer);
+    const started = Date.now();
+    while (inFlight > 0 && Date.now() - started < 3000) {
+      await new Promise((resolvePromise) => setTimeout(resolvePromise, 50));
+    }
+    if (queue.close) await queue.close();
+    process.exit(0);
+  }
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+export async function replayDeadLetter({ dir = ".fastscript", limit = 20, name = null, driver = process.env.JOBS_DRIVER || "file" } = {}) {
+  const queue = await createDistributedJobQueue({ dir, driver });
+  const replayed = await queue.replayDeadLetter({ limit, name });
+  if (queue.close) await queue.close();
+  return replayed;
+}

package/src/metrics.mjs

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+function readJson(path, fallback) {
+  if (!existsSync(path)) return fallback;
+  try { return JSON.parse(readFileSync(path, "utf8")); } catch { return fallback; }
+}
+
+function writeJson(path, value) {
+  writeFileSync(path, JSON.stringify(value, null, 2), "utf8");
+}
+
+export function createMetricsStore({ dir = ".fastscript", name = "metrics" } = {}) {
+  const root = resolve(dir);
+  mkdirSync(root, { recursive: true });
+  const file = join(root, `${name}.json`);
+  const state = readJson(file, { counters: {}, timings: {} });
+
+  function persist() {
+    writeJson(file, state);
+  }
+
+  return {
+    inc(counter, by = 1) {
+      state.counters[counter] = (state.counters[counter] || 0) + by;
+      persist();
+    },
+    observe(nameKey, valueMs) {
+      const row = state.timings[nameKey] || { count: 0, total: 0, min: null, max: null };
+      row.count += 1;
+      row.total += valueMs;
+      row.min = row.min === null ? valueMs : Math.min(row.min, valueMs);
+      row.max = row.max === null ? valueMs : Math.max(row.max, valueMs);
+      state.timings[nameKey] = row;
+      persist();
+    },
+    snapshot() {
+      const avg = {};
+      for (const [k, row] of Object.entries(state.timings)) {
+        avg[k] = row.count > 0 ? Number((row.total / row.count).toFixed(2)) : 0;
+      }
+      return { counters: { ...state.counters }, timings: { ...state.timings }, averages: avg };
+    },
+  };
+}

package/src/migration-wizard.mjs

@@ -0,0 +1,16 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { normalizeFastScript, stripTypeScriptHints } from "./fs-normalize.mjs";
+
+export async function runMigrationWizard(args = []) {
+  const pathArg = args[0] || "app/pages/index.js";
+  const abs = resolve(pathArg);
+  if (!existsSync(abs)) throw new Error(`migration wizard: file not found (${abs})`);
+  const raw = readFileSync(abs, "utf8");
+  let preview = raw;
+  if (/\.(ts|tsx)$/.test(abs)) preview = stripTypeScriptHints(preview);
+  preview = normalizeFastScript(preview, { file: abs, mode: "lenient" });
+  console.log("=== migration preview ===");
+  console.log(preview);
+  console.log("=== end preview ===");
+}

package/src/module-loader.mjs

@@ -1,24 +1,22 @@
-import { extname } from "node:path";
+import { extname } from "node:path";
 import { pathToFileURL } from "node:url";
 import esbuild from "esbuild";
-import {
-  createFastScriptDiagnosticError,
-  normalizeFastScriptWithTelemetry,
-} from "./fs-normalize.mjs";
+import { normalizeFastScript } from "./fs-normalize.mjs";
+import { assertFastScript } from "./fs-diagnostics.mjs";
 
 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",
+        };
       });
     },
   };
@@ -41,7 +39,8 @@ export async function importSourceModule(filePath, { platform = "node" } = {}) {
     plugins: [fsLoaderPlugin()],
     loader: { ".fs": "js" },
   });
+
   const code = result.outputFiles[0].text;
   const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
   return import(dataUrl);
-}
+}

package/src/oauth-providers.mjs

@@ -0,0 +1,103 @@
+import { buildOAuthAuthorizeUrl, createOAuthState } from "./auth-flows.mjs";
+
+const PROVIDERS = {
+  github: {
+    name: "GitHub",
+    authorizeUrl: "https://github.com/login/oauth/authorize",
+    tokenUrl: "https://github.com/login/oauth/access_token",
+    userUrl: "https://api.github.com/user",
+    scope: "read:user user:email",
+  },
+  google: {
+    name: "Google",
+    authorizeUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+    tokenUrl: "https://oauth2.googleapis.com/token",
+    userUrl: "https://www.googleapis.com/oauth2/v3/userinfo",
+    scope: "openid email profile",
+  },
+  microsoft: {
+    name: "Microsoft",
+    authorizeUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+    tokenUrl: "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+    userUrl: "https://graph.microsoft.com/v1.0/me",
+    scope: "openid profile email User.Read",
+  },
+};
+
+export function listAuthProviders() {
+  return Object.keys(PROVIDERS);
+}
+
+export function getAuthProvider(name) {
+  const key = String(name || "").toLowerCase();
+  const provider = PROVIDERS[key];
+  if (!provider) {
+    const error = new Error(`Unknown OAuth provider: ${name}`);
+    error.status = 400;
+    throw error;
+  }
+  return { id: key, ...provider };
+}
+
+export function createOAuthAdapter(name, {
+  clientId = process.env[`${String(name || "").toUpperCase()}_CLIENT_ID`],
+  clientSecret = process.env[`${String(name || "").toUpperCase()}_CLIENT_SECRET`],
+  redirectUri = process.env[`${String(name || "").toUpperCase()}_REDIRECT_URI`],
+} = {}) {
+  const provider = getAuthProvider(name);
+  return {
+    ...provider,
+    clientId,
+    clientSecret,
+    redirectUri,
+    authorizeUrl({ state = createOAuthState(), scope = provider.scope } = {}) {
+      return {
+        state,
+        url: buildOAuthAuthorizeUrl({
+          authorizeUrl: provider.authorizeUrl,
+          clientId,
+          redirectUri,
+          scope,
+          state,
+        }),
+      };
+    },
+    async exchangeCode(code) {
+      const body = new URLSearchParams({
+        grant_type: "authorization_code",
+        code,
+        client_id: clientId,
+        client_secret: clientSecret,
+        redirect_uri: redirectUri,
+      });
+      const response = await fetch(provider.tokenUrl, {
+        method: "POST",
+        headers: {
+          "content-type": "application/x-www-form-urlencoded",
+          accept: "application/json",
+        },
+        body,
+      });
+      if (!response.ok) {
+        const error = new Error(`OAuth token exchange failed (${response.status})`);
+        error.status = 502;
+        throw error;
+      }
+      return response.json();
+    },
+    async fetchUser(accessToken) {
+      const response = await fetch(provider.userUrl, {
+        headers: {
+          authorization: `Bearer ${accessToken}`,
+          accept: "application/json",
+        },
+      });
+      if (!response.ok) {
+        const error = new Error(`OAuth user fetch failed (${response.status})`);
+        error.status = 502;
+        throw error;
+      }
+      return response.json();
+    },
+  };
+}