fastscript 0.1.0

package/src/create.mjs

@@ -0,0 +1,190 @@
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+function ensureDir(path) {
+  if (!existsSync(path)) mkdirSync(path, { recursive: true });
+}
+
+export async function createApp(target = "app") {
+  const root = process.cwd();
+  const appRoot = join(root, target);
+  const pagesRoot = join(appRoot, "pages");
+
+  ensureDir(pagesRoot);
+  ensureDir(join(appRoot, "api"));
+  ensureDir(join(appRoot, "db", "migrations"));
+
+  const files = [
+    {
+      path: join(pagesRoot, "index.fs"),
+      content: `export default function Home() {
+  ~title = "Build full-stack apps with plain JavaScript."
+  return \`
+    <section class="hero">
+      <p class="eyebrow">FastScript</p>
+      <h1>\${title}</h1>
+      <p>Simple syntax, fast compiler pipeline, deploy anywhere.</p>
+      <button data-fs-counter>Counter: <span data-fs-counter-value>0</span></button>
+    </section>
+  \`;
+}
+
+export function hydrate({ root }) {
+  const btn = root.querySelector("[data-fs-counter]");
+  const value = root.querySelector("[data-fs-counter-value]");
+  if (!btn || !value) return;
+  let n = Number(value.textContent || "0");
+  btn.addEventListener("click", () => {
+    n += 1;
+    value.textContent = String(n);
+  });
+}
+`,
+    },
+    {
+      path: join(pagesRoot, "_layout.fs"),
+      content: `export default function Layout({ content, pathname, user }) {
+  return \`
+    <header class="nav">
+      <a href="/">FastScript</a>
+      <nav>
+        <a href="/">Home</a>
+        <a href="/private">Private</a>
+      </nav>
+      <small>\${user ? "Signed in" : "Guest"}</small>
+    </header>
+    <main class="page">\${content}</main>
+    <footer class="footer">Built with FastScript</footer>
+  \`;
+}
+`,
+    },
+    {
+      path: join(pagesRoot, "404.fs"),
+      content: `export default function NotFound() {
+  return \`<section><h1>404</h1><p>Page not found.</p></section>\`;
+}
+`,
+    },
+    {
+      path: join(pagesRoot, "private.fs"),
+      content: `export default function PrivatePage({ user }) {
+  return \`<section><h1>Private</h1><p>Hello \${user?.name ?? "anonymous"}</p></section>\`;
+}
+
+export async function GET(ctx) {
+  try {
+    const user = ctx.auth.requireUser();
+    return ctx.helpers.json({ ok: true, user });
+  } catch {
+    return ctx.helpers.redirect("/");
+  }
+}
+`,
+    },
+    {
+      path: join(appRoot, "styles.css"),
+      content: `:root { color-scheme: dark; }
+* { box-sizing: border-box; }
+body { margin: 0; font: 16px/1.6 ui-sans-serif, system-ui; background: #050505; color: #fff; }
+.nav { display: flex; justify-content: space-between; align-items: center; gap: 12px; padding: 16px 24px; border-bottom: 1px solid #1f1f1f; }
+.nav a { color: #d3d3ff; text-decoration: none; margin-right: 12px; }
+.page { max-width: 980px; margin: 0 auto; padding: 40px 24px; }
+.hero h1 { font-size: clamp(2rem, 6vw, 4rem); line-height: 1.05; margin: 0 0 10px; }
+.eyebrow { color: #9f92ff; font-size: 12px; text-transform: uppercase; letter-spacing: .12em; }
+.hero button { padding: 8px 12px; border: 1px solid #333; background: #0f0f0f; color: #fff; border-radius: 8px; cursor: pointer; }
+.footer { border-top: 1px solid #1f1f1f; padding: 24px; color: #8a8a8a; }
+`,
+    },
+    {
+      path: join(appRoot, "api", "hello.js"),
+      content: `export async function GET() {
+  return { status: 200, json: { ok: true, message: "Hello from FastScript API" } };
+}
+`,
+    },
+    {
+      path: join(appRoot, "api", "auth.js"),
+      content: `export const schemas = {
+  POST: { name: "string?" }
+};
+
+export async function POST(ctx) {
+  const body = await ctx.input.validateBody(schemas.POST);
+  const user = { id: "u_1", name: body.name || "Dev" };
+  ctx.auth.login(user);
+  return ctx.helpers.json({ ok: true, user });
+}
+
+export async function DELETE(ctx) {
+  ctx.auth.logout();
+  return ctx.helpers.json({ ok: true });
+}
+`,
+    },
+    {
+      path: join(appRoot, "api", "upload.js"),
+      content: `export const schemas = {
+  POST: { key: "string", content: "string" }
+};
+
+export async function POST(ctx) {
+  const body = await ctx.input.validateBody(schemas.POST);
+  const put = ctx.storage.put(body.key, Buffer.from(body.content, "utf8"));
+  return ctx.helpers.json({ ok: true, ...put, url: ctx.storage.url(body.key) });
+}
+`,
+    },
+    {
+      path: join(appRoot, "api", "webhook.js"),
+      content: `import { verifyWebhookRequest } from "../../src/webhook.mjs";
+
+export async function POST(ctx) {
+  const result = await verifyWebhookRequest(ctx.req, {
+    secret: process.env.WEBHOOK_SECRET || "dev-secret",
+    replayDir: ".fastscript"
+  });
+  if (!result.ok) return ctx.helpers.json({ ok: false, reason: result.reason }, 401);
+  return ctx.helpers.json({ ok: true });
+}
+`,
+    },
+    {
+      path: join(appRoot, "middleware.fs"),
+      content: `export async function middleware(ctx, next) {
+  const protectedRoute = ctx.pathname.startsWith("/private");
+  if (protectedRoute && !ctx.user) {
+    return ctx.helpers.redirect("/");
+  }
+  return next();
+}
+`,
+    },
+    {
+      path: join(appRoot, "db", "migrations", "001_init.js"),
+      content: `export async function up(db) {
+  const users = db.collection("users");
+  if (!users.get("u_1")) {
+    users.set("u_1", { id: "u_1", name: "Dev" });
+  }
+}
+`,
+    },
+    {
+      path: join(appRoot, "db", "seed.js"),
+      content: `export async function seed(db) {
+  db.transaction((tx) => {
+    tx.collection("posts").set("hello", { id: "hello", title: "First Post", published: true });
+  });
+}
+`,
+    },
+  ];
+
+  for (const file of files) {
+    if (!existsSync(file.path)) writeFileSync(file.path, file.content, "utf8");
+  }
+
+  const count = readdirSync(pagesRoot).length;
+  console.log(`created ${target} with ${count} page file(s)`);
+}

package/src/db-cli.mjs

@@ -0,0 +1,45 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createFileDatabase } from "./db.mjs";
+
+const MIGRATIONS_DIR = resolve("app/db/migrations");
+const SEED_FILE = resolve("app/db/seed.js");
+
+async function importFresh(path) {
+  return import(`${pathToFileURL(path).href}?t=${Date.now()}`);
+}
+
+export async function runDbMigrate() {
+  const db = createFileDatabase({ dir: ".fastscript", name: "appdb" });
+  if (!existsSync(MIGRATIONS_DIR)) {
+    console.log("db migrate: no app/db/migrations directory");
+    return;
+  }
+  const files = readdirSync(MIGRATIONS_DIR).filter((f) => /\.(js|mjs|cjs)$/.test(f)).sort();
+  let count = 0;
+  for (const file of files) {
+    const mod = await importFresh(join(MIGRATIONS_DIR, file));
+    const fn = mod.up ?? mod.default;
+    if (typeof fn === "function") {
+      await fn(db);
+      count += 1;
+      console.log(`db migrate: applied ${file}`);
+    }
+  }
+  console.log(`db migrate complete: ${count} migration(s)`);
+}
+
+export async function runDbSeed() {
+  const db = createFileDatabase({ dir: ".fastscript", name: "appdb" });
+  if (!existsSync(SEED_FILE)) {
+    console.log("db seed: no app/db/seed.js file");
+    return;
+  }
+  const mod = await importFresh(SEED_FILE);
+  const fn = mod.seed ?? mod.default;
+  if (typeof fn !== "function") throw new Error("app/db/seed.js must export seed(db) or default(db)");
+  await fn(db);
+  console.log("db seed complete");
+}
+

package/src/db-postgres.mjs

@@ -0,0 +1,40 @@
+export async function createPostgresAdapter({ connectionString = process.env.DATABASE_URL } = {}) {
+  const { Client } = await import("pg");
+  const client = new Client({ connectionString });
+  await client.connect();
+
+  return {
+    async query(sql, params = []) {
+      const res = await client.query(sql, params);
+      return res.rows;
+    },
+    async transaction(fn) {
+      await client.query("BEGIN");
+      try {
+        const out = await fn({ query: (sql, params = []) => client.query(sql, params).then((r) => r.rows) });
+        await client.query("COMMIT");
+        return out;
+      } catch (e) {
+        await client.query("ROLLBACK");
+        throw e;
+      }
+    },
+    async migrate(lockId = 4839201, migrations = []) {
+      await client.query("SELECT pg_advisory_lock($1)", [lockId]);
+      try {
+        await client.query("CREATE TABLE IF NOT EXISTS fs_migrations (id text primary key, applied_at timestamptz not null default now())");
+        const done = new Set((await client.query("SELECT id FROM fs_migrations")).rows.map((r) => r.id));
+        for (const m of migrations) {
+          if (done.has(m.id)) continue;
+          await m.up({ query: (sql, params = []) => client.query(sql, params).then((r) => r.rows) });
+          await client.query("INSERT INTO fs_migrations(id) VALUES($1)", [m.id]);
+        }
+      } finally {
+        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
+      }
+    },
+    async close() {
+      await client.end();
+    },
+  };
+}

package/src/db.mjs

@@ -0,0 +1,103 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } 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 createFileDatabase({ dir = ".fastscript", name = "appdb" } = {}) {
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `${name}.json`);
+  const state = readJson(path, { collections: {} });
+
+  function persist() {
+    writeJson(path, state);
+  }
+
+  function ensureCollection(collection) {
+    if (!state.collections[collection]) state.collections[collection] = {};
+    return state.collections[collection];
+  }
+
+  return {
+    collection(name) {
+      return {
+        get(id) {
+          const col = ensureCollection(name);
+          return col[id] ?? null;
+        },
+        set(id, value) {
+          const col = ensureCollection(name);
+          col[id] = value;
+          persist();
+          return col[id];
+        },
+        delete(id) {
+          const col = ensureCollection(name);
+          delete col[id];
+          persist();
+        },
+        all() {
+          const col = ensureCollection(name);
+          return Object.values(col);
+        },
+        upsert(id, updater) {
+          const col = ensureCollection(name);
+          const prev = col[id] ?? null;
+          const next = typeof updater === "function" ? updater(prev) : updater;
+          col[id] = next;
+          persist();
+          return next;
+        },
+        first(predicate) {
+          const col = ensureCollection(name);
+          return Object.values(col).find(predicate) ?? null;
+        },
+        where(filters) {
+          const col = ensureCollection(name);
+          if (typeof filters === "function") return Object.values(col).filter(filters);
+          return Object.values(col).filter((row) =>
+            Object.entries(filters || {}).every(([k, v]) => row?.[k] === v),
+          );
+        },
+      };
+    },
+    transaction(fn) {
+      const snapshot = JSON.stringify(state);
+      try {
+        const res = fn(this);
+        persist();
+        return res;
+      } catch (error) {
+        const rollback = JSON.parse(snapshot);
+        state.collections = rollback.collections ?? {};
+        persist();
+        throw error;
+      }
+    },
+    query(collection, predicate) {
+      const col = ensureCollection(collection);
+      return Object.values(col).filter(predicate);
+    },
+    first(collection, predicate) {
+      const col = ensureCollection(collection);
+      return Object.values(col).find(predicate) ?? null;
+    },
+    where(collection, filters) {
+      const col = ensureCollection(collection);
+      if (typeof filters === "function") return Object.values(col).filter(filters);
+      return Object.values(col).filter((row) =>
+        Object.entries(filters || {}).every(([k, v]) => row?.[k] === v),
+      );
+    },
+  };
+}

package/src/deploy.mjs

@@ -0,0 +1,65 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+
+export async function runDeploy(args = []) {
+  let target = "node";
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--target") target = (args[i + 1] || "node").toLowerCase();
+  }
+
+  const root = resolve(process.cwd());
+
+  if (target === "node" || target === "pm2") {
+    const file = join(root, "ecosystem.config.cjs");
+    writeFileSync(
+      file,
+      `module.exports = { apps: [{ name: "fastscript-app", script: "node", args: "./src/cli.mjs start", env: { NODE_ENV: "production", PORT: 4173 } }] };\n`,
+      "utf8",
+    );
+    writeFileSync(
+      join(root, "Dockerfile"),
+      `FROM node:20-alpine\nWORKDIR /app\nCOPY package*.json ./\nRUN npm ci --omit=dev\nCOPY . .\nRUN npm run build\nENV NODE_ENV=production\nEXPOSE 4173\nCMD [\"node\",\"./src/cli.mjs\",\"start\"]\n`,
+      "utf8",
+    );
+    console.log("deploy adapter ready: ecosystem.config.cjs (PM2/Node)");
+    return;
+  }
+
+  if (target === "vercel") {
+    const file = join(root, "vercel.json");
+    writeFileSync(
+      file,
+      JSON.stringify(
+        {
+          version: 2,
+          builds: [{ src: "package.json", use: "@vercel/node" }],
+          routes: [{ src: "/(.*)", dest: "/src/cli.mjs" }],
+        },
+        null,
+        2,
+      ),
+      "utf8",
+    );
+    console.log("deploy adapter ready: vercel.json");
+    return;
+  }
+
+  if (target === "cloudflare") {
+    const wrangler = join(root, "wrangler.toml");
+    writeFileSync(
+      wrangler,
+      `name = "fastscript-app"\nmain = "dist/worker.js"\ncompatibility_date = "2026-01-01"\n[assets]\ndirectory = "dist"\n`,
+      "utf8",
+    );
+    mkdirSync(join(root, "dist"), { recursive: true });
+    writeFileSync(
+      join(root, "dist", "worker.js"),
+      `export default { async fetch(req, env) { return env.ASSETS.fetch(req); } };\n`,
+      "utf8",
+    );
+    console.log("deploy adapter ready: wrangler.toml + dist/worker.js");
+    return;
+  }
+
+  throw new Error(`Unknown deploy target: ${target}. Use node|pm2|vercel|cloudflare`);
+}

package/src/dev.mjs

@@ -0,0 +1,5 @@
+import { runServer } from "./server-runtime.mjs";
+
+export async function runDev() {
+  await runServer({ mode: "development", watchMode: true, buildOnStart: true, port: 4173 });
+}

package/src/env.mjs

@@ -0,0 +1,89 @@
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+function parseDotEnv(raw) {
+  const out = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const idx = trimmed.indexOf("=");
+    if (idx <= 0) continue;
+    const key = trimmed.slice(0, idx).trim();
+    let val = trimmed.slice(idx + 1).trim();
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) val = val.slice(1, -1);
+    out[key] = val;
+  }
+  return out;
+}
+
+export function loadEnv({ root = process.cwd(), mode = process.env.NODE_ENV || "development" } = {}) {
+  const files = [".env", `.env.${mode}`, mode === "production" ? ".env.local" : null].filter(Boolean);
+  const merged = {};
+  for (const file of files) {
+    const path = join(root, file);
+    if (!existsSync(path)) continue;
+    Object.assign(merged, parseDotEnv(readFileSync(path, "utf8")));
+  }
+  for (const [k, v] of Object.entries(merged)) if (process.env[k] === undefined) process.env[k] = v;
+  return { mode, values: merged };
+}
+
+export function validateEnv(schema = {}, env = process.env) {
+  const errors = [];
+  const out = {};
+  for (const [key, ruleRaw] of Object.entries(schema || {})) {
+    const rule = typeof ruleRaw === "string" ? { type: ruleRaw } : { ...(ruleRaw || {}) };
+    const type = String(rule.type || "string").replace(/\?$/, "");
+    const optional = String(rule.type || "").endsWith("?") || rule.optional === true;
+    const value = env[key];
+    if (value === undefined || value === "") {
+      if (!optional) errors.push(`${key} is required`);
+      continue;
+    }
+    if (type === "int") {
+      const n = Number(value);
+      if (!Number.isInteger(n)) errors.push(`${key} must be int`); else out[key] = n;
+      continue;
+    }
+    if (type === "float" || type === "number") {
+      const n = Number(value);
+      if (!Number.isFinite(n)) errors.push(`${key} must be number`); else out[key] = n;
+      continue;
+    }
+    if (type === "bool" || type === "boolean") {
+      if (!["true", "false", true, false].includes(value)) errors.push(`${key} must be boolean`);
+      else out[key] = value === true || value === "true";
+      continue;
+    }
+    out[key] = String(value);
+  }
+  if (errors.length) {
+    const error = new Error(`Env validation failed: ${errors.join("; ")}`);
+    error.status = 500;
+    error.details = errors;
+    throw error;
+  }
+  return out;
+}
+
+export async function validateAppEnv({ root = process.cwd() } = {}) {
+  const schemaPath = join(root, "app", "env.schema.js");
+  if (!existsSync(schemaPath)) return null;
+  const mod = await import(`${pathToFileURL(schemaPath).href}?t=${Date.now()}`);
+  const schema = mod.schema || mod.default || {};
+  return validateEnv(schema, process.env);
+}
+
+export function ensureEnvExample() {
+  const example = join(process.cwd(), ".env.example");
+  if (existsSync(example)) return;
+  writeFileSync(example, "# FastScript env template\nSESSION_SECRET=change_me\n", "utf8");
+}
+
+export function appendEnvIfMissing(key, value) {
+  const path = join(process.cwd(), ".env");
+  const current = existsSync(path) ? readFileSync(path, "utf8") : "";
+  if (current.includes(`${key}=`)) return;
+  appendFileSync(path, `${key}=${value}\n`, "utf8");
+}

package/src/export.mjs

@@ -0,0 +1,83 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, relative, resolve } from "node:path";
+import { normalizeFastScript } from "./fs-normalize.mjs";
+
+const VALID_TARGETS = new Set(["js", "ts"]);
+
+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 if (entry.isFile()) out.push(full);
+  }
+  return out;
+}
+
+function rewriteImportsForTarget(source, to) {
+  let out = source
+    .replace(/from\s+["'](\.\/[^"']+)\.fs["']/g, `from "$1.${to}"`)
+    .replace(/from\s+["'](\.\.\/[^"']+)\.fs["']/g, `from "$1.${to}"`)
+    .replace(/import\(\s*["'](\.\/[^"']+)\.fs["']\s*\)/g, `import("$1.${to}")`)
+    .replace(/import\(\s*["'](\.\.\/[^"']+)\.fs["']\s*\)/g, `import("$1.${to}")`);
+  out = out
+    .replace(/require\(\s*["'](\.\/[^"']+)\.fs["']\s*\)/g, `require("$1.${to}")`)
+    .replace(/require\(\s*["'](\.\.\/[^"']+)\.fs["']\s*\)/g, `require("$1.${to}")`);
+  return out;
+}
+
+function toTargetPath(file, to) {
+  if (extname(file) === ".fs") return file.replace(/\.fs$/, `.${to}`);
+  return file;
+}
+
+export async function runExport(args = []) {
+  let to = "js";
+  let out = "exported-app";
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--to") to = (args[i + 1] || "").toLowerCase();
+    if (arg === "--out") out = args[i + 1] || out;
+  }
+
+  if (!VALID_TARGETS.has(to)) {
+    throw new Error('Invalid export target. Use: fastscript export --to js|ts');
+  }
+
+  const appDir = resolve("app");
+  const outDir = resolve(out);
+  if (!existsSync(appDir)) throw new Error("Missing app directory.");
+
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(outDir, { recursive: true });
+
+  // Copy non-page assets/directories first.
+  for (const entry of readdirSync(appDir, { withFileTypes: true })) {
+    if (entry.name === "pages") continue;
+    const src = join(appDir, entry.name);
+    const dest = join(outDir, entry.name);
+    if (entry.isDirectory()) cpSync(src, dest, { recursive: true });
+    else cpSync(src, dest);
+  }
+
+  const pageRoot = join(appDir, "pages");
+  const pageFiles = walk(pageRoot);
+  for (const file of pageFiles) {
+    const rel = relative(appDir, file);
+    const nextPath = toTargetPath(rel, to);
+    const outFile = join(outDir, nextPath);
+    mkdirSync(dirname(outFile), { recursive: true });
+
+    const ext = extname(file);
+    let source = readFileSync(file, "utf8");
+    if (ext === ".fs") source = normalizeFastScript(source);
+    source = rewriteImportsForTarget(source, to);
+    if (to === "ts") source = `// @ts-nocheck\n${source}`;
+
+    writeFileSync(outFile, source, "utf8");
+  }
+
+  console.log(`export complete: app -> ${out} (target: ${to})`);
+}