@teyik0/furin 0.1.0-alpha.3

package/src/build/route-types.ts

@@ -0,0 +1,88 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ResolvedRoute } from "../router";
+
+/** @internal Exported for unit testing only. */
+export function patternToTypeString(pattern: string): string {
+  // biome-ignore lint/suspicious/noTemplateCurlyInString: intentional — generates TS template literal syntax
+  const t = pattern.replace(/:[^/]+/g, "${string}").replace(/\*/g, "${string}");
+  return t.includes("${") ? `\`${t}\`` : `"${t}"`;
+}
+
+/**
+ * Converts a runtime TypeBox/JSON Schema object to a TypeScript type string.
+ * Handles the common cases found in Elysia query schemas (string, number, boolean,
+ * optional fields, nullable via anyOf).
+ *
+ * @internal Exported for unit testing only.
+ */
+export function schemaToTypeString(schema: unknown): string {
+  if (!schema || typeof schema !== "object") {
+    return "unknown";
+  }
+  const s = schema as Record<string, unknown>;
+  if (s.anyOf && Array.isArray(s.anyOf)) {
+    const parts = (s.anyOf as unknown[]).map(schemaToTypeString).filter((t) => t !== "null");
+    return parts.join(" | ") || "unknown";
+  }
+  switch (s.type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "object": {
+      if (!s.properties || typeof s.properties !== "object") {
+        return "Record<string, unknown>";
+      }
+      const required = new Set<string>(Array.isArray(s.required) ? (s.required as string[]) : []);
+      const props = Object.entries(s.properties as Record<string, unknown>)
+        .map(([k, v]) => `${k}${required.has(k) ? "" : "?"}: ${schemaToTypeString(v)}`)
+        .join("; ");
+      return `{ ${props} }`;
+    }
+    default:
+      return "unknown";
+  }
+}
+
+/**
+ * Generates .furin/routes.d.ts — augments RouteManifest in furin/link
+ * so that <Link to="..."> has type-safe autocompletion and <Link search={...}>
+ * is typed per-route from the route's query schema.
+ *
+ * Users must add ".furin/routes.d.ts" to their tsconfig.json "include" array once.
+ */
+/** @internal Exported for unit testing only. */
+export function writeRouteTypes(routes: ResolvedRoute[], outDir: string): void {
+  const entries = routes.map((r) => {
+    const typeKey = patternToTypeString(r.pattern);
+    const isDynamic = typeKey.startsWith("`");
+    const querySchema = r.routeChain?.find((rt) => rt.query)?.query;
+    const searchType = querySchema ? schemaToTypeString(querySchema) : "never";
+    return isDynamic
+      ? `    [key: ${typeKey}]: { search?: ${searchType} }`
+      : `    ${typeKey}: { search?: ${searchType} }`;
+  });
+
+  const content = `// Auto-generated by Furin. Do not edit manually.
+// Add ".furin/routes.d.ts" to your tsconfig.json "include" array to enable typed navigation.
+import "@teyik0/furin/link";
+
+declare module "@teyik0/furin/link" {
+  interface RouteManifest {
+${entries.join(";\n")};
+  }
+}
+`;
+
+  const typesPath = join(outDir, "routes.d.ts");
+  const existing = existsSync(typesPath) ? readFileSync(typesPath, "utf8") : "";
+  if (content !== existing) {
+    writeFileSync(typesPath, content);
+  }
+}

package/src/build/scan-server.ts

@@ -0,0 +1,88 @@
+import { readFileSync } from "node:fs";
+import { parseSync } from "oxc-parser";
+
+// Minimal AST node shapes — just what we need
+interface AstNode {
+  type: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Statically scans a server entry file and returns all `pagesDir` string
+ * literal values found inside `furin({ pagesDir: "..." })` call expressions.
+ *
+ * Dynamic paths (template literals, variables) are silently ignored.
+ * Returns an empty array when nothing is detected.
+ */
+export function scanFurinInstances(serverEntryPath: string): string[] {
+  const code = readFileSync(serverEntryPath, "utf8");
+  const { program, errors } = parseSync(serverEntryPath, code);
+  if (errors.length > 0) {
+    return [];
+  }
+
+  const results: string[] = [];
+  walkNode(program as unknown as AstNode, results);
+  return results;
+}
+
+function walkNode(node: AstNode, out: string[]): void {
+  if (!node || typeof node !== "object") return;
+
+  if (node.type === "CallExpression") {
+    const callee = node.callee as AstNode | undefined;
+    const args = node.arguments as AstNode[] | undefined;
+
+    const isElyraCall =
+      callee?.type === "Identifier" && (callee as { name?: string }).name === "furin";
+
+    if (isElyraCall && Array.isArray(args) && args.length > 0) {
+      const firstArg = args[0] as AstNode;
+      if (firstArg?.type === "ObjectExpression") {
+        const pagesDir = extractStringProperty(firstArg, "pagesDir");
+        if (pagesDir !== null) {
+          out.push(pagesDir);
+        }
+      }
+    }
+  }
+
+  // Recurse into all child node values
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item === "object") {
+          walkNode(item as AstNode, out);
+        }
+      }
+    } else if (child && typeof child === "object") {
+      walkNode(child as AstNode, out);
+    }
+  }
+}
+
+function extractStringProperty(obj: AstNode, propName: string): string | null {
+  const properties = obj.properties as AstNode[] | undefined;
+  if (!Array.isArray(properties)) return null;
+
+  for (const prop of properties) {
+    if (prop.type !== "Property") continue;
+    const key = prop.key as AstNode & { name?: string; value?: unknown };
+    const value = prop.value as AstNode & { value?: unknown };
+
+    const keyMatches =
+      (key.type === "Identifier" && key.name === propName) ||
+      (key.type === "Literal" && key.value === propName);
+
+    if (!keyMatches) continue;
+
+    // Only accept string literals — ignore template literals, identifiers, etc.
+    if (value?.type === "Literal" && typeof value.value === "string") {
+      return value.value;
+    }
+    return null; // dynamic path — silently skip
+  }
+  return null;
+}

package/src/build/server-routes-entry.ts

@@ -0,0 +1,38 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { buildEntrySource } from "./entry-template";
+import { ensureDir } from "./shared";
+
+export interface ServerRoutesEntryOptions {
+  outDir: string;
+  rootPath: string;
+  routes: Array<{ mode: "ssr" | "ssg" | "isr"; path: string; pattern: string }>;
+  serverEntry: string;
+}
+
+/**
+ * Generates `server.ts` — an intermediate entry used to produce `server.js`.
+ *
+ * Equivalent to `_compile-entry.ts` but for disk (non-binary) production builds:
+ * 1. Statically imports every page module so Bun bundles them into server.js
+ * 2. Sets production mode and registers everything in a single CompileContext
+ * 3. Imports server.ts to boot the app
+ *
+ * This file is intermediate: `adapter/bun.ts` runs `Bun.build()` on it to produce
+ * the self-contained `server.js` bundle, then deletes this file.
+ */
+export function generateServerRoutesEntry(options: ServerRoutesEntryOptions): string {
+  const { outDir, rootPath, routes, serverEntry } = options;
+  ensureDir(outDir);
+  const source = buildEntrySource({
+    headerComment: "// Auto-generated by furin build — do not edit",
+    rootPath,
+    routes,
+    serverEntry,
+  });
+
+  // Named "server.ts" so Bun.build() outputs "server.js"
+  const entryPath = join(outDir, "server.ts");
+  writeFileSync(entryPath, source);
+  return entryPath;
+}

package/src/build/shared.ts

@@ -0,0 +1,80 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import type { BuildTarget } from "../config";
+import type { ResolvedRoute } from "../router";
+import type { BuildRouteManifestEntry, TargetBuildManifest } from "./types";
+
+export const CLIENT_MODULE_PATH = resolve(import.meta.dir, "../client.ts").replace(/\\/g, "/");
+export const LINK_MODULE_PATH = resolve(import.meta.dir, "../link.tsx").replace(/\\/g, "/");
+
+export function ensureDir(path: string): void {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+
+export function toPosixPath(path: string): string {
+  return path.replace(/\\/g, "/");
+}
+
+export function collectFilesRecursive(dir: string): string[] {
+  const files: string[] = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const absolutePath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectFilesRecursive(absolutePath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(absolutePath);
+    }
+  }
+
+  return files.sort();
+}
+
+export function copyDirRecursive(sourceDir: string, targetDir: string): void {
+  rmSync(targetDir, { force: true, recursive: true });
+  cpSync(sourceDir, targetDir, { recursive: true });
+}
+
+export function toBuildRouteManifestEntry(
+  route: ResolvedRoute,
+  rootDir: string
+): BuildRouteManifestEntry {
+  return {
+    pattern: route.pattern,
+    mode: route.mode,
+    pagePath: toPosixPath(relative(rootDir, route.path)),
+    hasLayout: route.routeChain.some((entry) => !!entry.layout),
+    hasStaticParams: !!route.page?.staticParams,
+    revalidate: route.page?._route.revalidate ?? null,
+  };
+}
+
+export function buildTargetManifest(
+  rootDir: string,
+  buildRoot: string,
+  target: BuildTarget,
+  serverEntry: string | null
+): TargetBuildManifest {
+  const targetDir = join(buildRoot, target);
+  const manifestPath = join(targetDir, "manifest.json");
+
+  return {
+    generatedAt: new Date().toISOString(),
+    targetDir: toPosixPath(relative(rootDir, targetDir)),
+    clientDir: toPosixPath(relative(rootDir, join(targetDir, "client"))),
+    templatePath: toPosixPath(relative(rootDir, join(targetDir, "client", "index.html"))),
+    manifestPath: toPosixPath(relative(rootDir, manifestPath)),
+    serverPath: null,
+    serverEntry: serverEntry ? toPosixPath(relative(rootDir, serverEntry)) : null,
+  };
+}
+
+export function writeTargetManifest(targetDir: string, targetManifest: TargetBuildManifest): void {
+  const manifestPath = join(targetDir, "manifest.json");
+  writeFileSync(manifestPath, `${JSON.stringify(targetManifest, null, 2)}\n`);
+}

package/src/build/types.ts

@@ -0,0 +1,60 @@
+import type { BuildTarget } from "../config";
+import type { ResolvedRoute } from "../router";
+
+export interface BuildClientOptions {
+  outDir: string;
+  pagesDir?: string;
+  plugins?: Bun.BunPlugin[];
+  rootLayout: string;
+}
+
+export interface BuildRouteManifestEntry {
+  hasLayout: boolean;
+  hasStaticParams: boolean;
+  mode: ResolvedRoute["mode"];
+  pagePath: string;
+  pattern: string;
+  revalidate: number | null;
+}
+
+export interface TargetBuildManifest {
+  clientDir: string;
+  generatedAt: string;
+  manifestPath: string;
+  serverEntry: string | null;
+  serverPath: string | null;
+  targetDir: string;
+  templatePath: string;
+}
+
+export interface BuildManifest {
+  generatedAt: string;
+  pagesDir: string;
+  rootDir: string;
+  rootPath: string;
+  routes: BuildRouteManifestEntry[];
+  serverEntry: string | null;
+  targets: Partial<Record<BuildTarget, TargetBuildManifest>>;
+  version: 1;
+}
+
+export interface BuildAppOptions {
+  compile?: "server" | "embed";
+  pagesDir?: string;
+  plugins?: Bun.BunPlugin[];
+  rootDir?: string;
+  serverEntry?: string;
+  target: BuildTarget | "all";
+}
+
+export interface BuildAppResult {
+  manifest: BuildManifest;
+  targets: Partial<Record<BuildTarget, TargetBuildManifest>>;
+}
+
+export type BunBuildAliasConfig = Bun.BuildConfig & {
+  alias?: Record<string, string>;
+  outfile?: string;
+  packages?: "bundle" | "external";
+  write?: boolean;
+};

package/src/cli/config.ts

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { TypeCompiler } from "elysia/type-system";
+import { configSchema, type FurinConfig } from "../config.ts";
+
+const compiledConfigSchema = TypeCompiler.Compile(configSchema);
+
+const DEFAULT_CONFIG_FILENAMES = [
+  "furin.config.ts",
+  "furin.config.js",
+  "furin.config.mjs",
+] as const;
+
+interface ResolvedCliConfig extends FurinConfig {
+  configPath: string | null;
+  pagesDir: string;
+  plugins?: Bun.BunPlugin[];
+  rootDir: string;
+}
+
+export async function loadCliConfig(
+  cwd: string,
+  explicitConfigPath?: string
+): Promise<ResolvedCliConfig> {
+  const rootDir = resolve(cwd);
+  const configPath = explicitConfigPath
+    ? resolve(rootDir, explicitConfigPath)
+    : DEFAULT_CONFIG_FILENAMES.map((filename) => resolve(rootDir, filename)).find((path) =>
+        existsSync(path)
+      );
+
+  if (!configPath) {
+    return {
+      configPath: null,
+      rootDir,
+      pagesDir: resolve(rootDir, "src/pages"),
+    };
+  }
+
+  const imported = await import(pathToFileURL(configPath).href);
+  const rawConfig: FurinConfig = imported.default ?? imported;
+
+  // Extract plugins before TypeBox validation: functions cannot be JSON-schema validated
+  const { plugins, ...configToValidate } = rawConfig;
+
+  if (plugins !== undefined && !Array.isArray(plugins)) {
+    throw new Error(
+      `[furin] Invalid config at ${configPath}: "plugins" must be an array of BunPlugin objects`
+    );
+  }
+
+  if (!compiledConfigSchema.Check(configToValidate)) {
+    const [firstError] = compiledConfigSchema.Errors(configToValidate);
+    throw new Error(
+      `[furin] Invalid config at ${configPath}: ${firstError?.message ?? "unknown error"} (path: ${firstError?.path ?? "/"})`
+    );
+  }
+
+  const resolvedRootDir = resolve(rootDir, configToValidate.rootDir ?? ".");
+  return {
+    ...configToValidate,
+    plugins,
+    configPath,
+    rootDir: resolvedRootDir,
+    pagesDir: resolve(resolvedRootDir, configToValidate.pagesDir ?? "src/pages"),
+  };
+}

package/src/cli/index.ts

@@ -0,0 +1,106 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { buildApp } from "../build/index.ts";
+import { BUILD_TARGETS, type BuildTarget } from "../config.ts";
+import { loadCliConfig } from "./config.ts";
+
+const argv = process.argv.slice(2);
+const command = argv[0];
+
+function log(msg: string): void {
+  console.log(`\x1b[32m◆\x1b[0m ${msg}`);
+}
+
+function bail(msg: string): never {
+  console.error(`\x1b[31m✗\x1b[0m ${msg}`);
+  process.exit(1);
+}
+
+function resolveCompileMode(
+  flag: string | boolean | undefined,
+  configCompile: "server" | "embed" | undefined
+): "server" | "embed" | undefined {
+  if (flag === "embed") {
+    return "embed";
+  }
+  if (flag === true || flag === "server") {
+    return "server";
+  }
+  if (flag !== undefined && flag !== false) {
+    bail(`Invalid compile mode "${flag}". Valid: --compile server or --compile embed`);
+  }
+  return configCompile;
+}
+
+if (command === "build") {
+  const { values: rawValues } = parseArgs({
+    args: argv.slice(1),
+    options: {
+      target: { type: "string" },
+      pagesDir: { type: "string" },
+      config: { type: "string" },
+    },
+    strict: false,
+  });
+
+  const values = rawValues as {
+    target?: string;
+    pagesDir?: string;
+    config?: string;
+  };
+
+  // --compile has an optional value: absent → undefined, present alone → true, present with "embed" → "embed"
+  const buildArgv = argv.slice(1);
+  const compileIdx = buildArgv.indexOf("--compile");
+  let compileFlag: string | boolean | undefined;
+  if (compileIdx < 0) {
+    compileFlag = undefined;
+  } else {
+    const next = buildArgv[compileIdx + 1];
+    compileFlag = next && !next.startsWith("-") ? next : true;
+  }
+
+  const target = values.target ?? "bun";
+
+  if (target !== "all" && !(BUILD_TARGETS as readonly string[]).includes(target)) {
+    bail(`Unsupported build target "${target}". Valid: ${BUILD_TARGETS.join(", ")}, all`);
+  }
+
+  const config = await loadCliConfig(process.cwd(), values.config);
+
+  const resolvedServerEntry = resolve(config.rootDir, config.serverEntry ?? "src/server.ts");
+  if (!existsSync(resolvedServerEntry)) {
+    const expected = config.serverEntry ?? "src/server.ts";
+    throw new Error(`[furin] Entrypoint ${expected} not found`);
+  }
+
+  log(`Building Furin for ${target}…`);
+
+  const result = await buildApp({
+    target: target as BuildTarget | "all",
+    compile: resolveCompileMode(compileFlag, config.bun?.compile),
+    rootDir: config.rootDir,
+    pagesDir: values.pagesDir ?? config.pagesDir,
+    serverEntry: resolvedServerEntry,
+    plugins: config.plugins,
+  });
+
+  const built = Object.keys(result.targets).join(", ") || "none";
+  log(`Done: ${built} → .furin/build`);
+} else if (!command || command === "help") {
+  console.log(
+    `Furin CLI
+
+USAGE  furin build [options]
+
+OPTIONS
+  --target    ${BUILD_TARGETS.join(" | ")} | all  (default: bun)
+  --pagesDir  Pages directory
+  --config    Config file path
+  --compile   server | embed  Compile to binary: "server" keeps client on disk, "embed" is self-contained
+`
+  );
+} else {
+  bail(`Unknown command "${command}". Run "furin help" for usage.`);
+}