@flow-os/server 0.0.47-dev.1772052157

package/config/server/routes/api.ts

@@ -0,0 +1,3 @@
+import { Route } from '@flow-os/server';
+
+export default Route(() => ({ message: 'Hello from APIdwdw' }));

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@flow-os/server",
+  "version": "0.0.47-dev.1772052157",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "flow-os-server": "./src/bin.ts"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "peerDependencies": {
+    "vite": ">=7.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "bun-types": "^1.3.9",
+    "vite": ">=7.0.0"
+  }
+}

package/src/bin.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+import { runProductionServer } from "./production.js";
+runProductionServer();

package/src/index.ts

@@ -0,0 +1,4 @@
+export { flowServer, flowServerMiddleware } from './plugin.js';
+export { createFlowServer } from './router.js';
+export { Route, type FlowHandler } from './route.js';
+export { runProductionServer } from './production.js';

package/src/plugin.ts

@@ -0,0 +1,81 @@
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { Plugin } from 'vite';
+import { createFlowServer, type LoadHandler } from './router.js';
+import type { FlowHandler } from './route.js';
+
+type NodeReq = import('node:http').IncomingMessage;
+type NodeRes = import('node:http').ServerResponse;
+
+function nodeRequestToWebRequest(req: NodeReq, baseUrl: string): Request {
+  const url = (req.url ?? '/').startsWith('http') ? req.url! : baseUrl + (req.url ?? '/');
+  const opts: RequestInit = {
+    method: req.method ?? 'GET',
+    headers: req.headers as HeadersInit,
+  };
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    (opts as RequestInit & { duplex?: string }).body = req as unknown as BodyInit;
+    (opts as RequestInit & { duplex?: string }).duplex = 'half';
+  }
+  return new Request(url, opts);
+}
+
+async function webResponseToNodeResponse(webRes: Response, res: NodeRes): Promise<void> {
+  res.writeHead(webRes.status, Object.fromEntries(webRes.headers));
+  if (webRes.body) {
+    const buf = Buffer.from(await webRes.arrayBuffer());
+    res.end(buf);
+  } else {
+    res.end();
+  }
+}
+
+export function flowServerMiddleware(
+  dispatch: (pathname: string, method: string, request: Request) => Promise<Response | null>,
+  matches: (pathname: string, method: string) => boolean
+): (req: NodeReq, res: NodeRes, next: () => void) => void {
+  return (req, res, next) => {
+    const pathname = req.url?.split('?')[0] ?? '/';
+    const method = req.method ?? 'GET';
+    if (!matches(pathname, method)) return next();
+    const baseUrl = `http://${req.headers.host ?? 'localhost'}`;
+    const request = nodeRequestToWebRequest(req, baseUrl);
+    dispatch(pathname, method, request)
+      .then((response) => {
+        if (response) return webResponseToNodeResponse(response, res);
+        next();
+      })
+      .catch((err) => {
+        console.error('[flow-os:server]', err);
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err?.message ?? String(err) }));
+      });
+  };
+}
+
+export type FlowServerOptions = {
+  /** Cartella route API (file-based). Default: server/routes */
+  routesDir?: string;
+};
+
+type ConnectStack = Array<{ route: string; handle: (req: NodeReq, res: NodeRes, next: () => void) => void }>;
+
+export function flowServer(options?: FlowServerOptions): Plugin {
+  return {
+    name: 'flow-os:server',
+    enforce: 'pre',
+    apply: 'serve',
+    configureServer: async (server) => {
+      const root = server.config.root ?? process.cwd();
+      const routesDir = options?.routesDir ?? resolve(root, 'server', 'routes');
+      const loadHandler: LoadHandler = (filePath) =>
+        server.ssrLoadModule(pathToFileURL(filePath).href) as Promise<{ default: FlowHandler }>;
+      const { dispatch, matches } = await createFlowServer(routesDir, loadHandler);
+      const middleware = flowServerMiddleware(dispatch, matches);
+      (server.middlewares as unknown as { stack: ConnectStack }).stack.unshift({
+        route: '',
+        handle: middleware,
+      });
+    },
+  };
+}

package/src/production.ts

@@ -0,0 +1,58 @@
+import { createServer } from "node:http";
+import { createReadStream, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createFlowServer } from "./router.js";
+import { flowServerMiddleware } from "./plugin.js";
+import type { FlowHandler } from "./route.js";
+
+export type ProductionServerOptions = {
+  routesDir?: string;
+  staticDir?: string;
+  port?: number;
+  hostname?: string;
+};
+
+export async function runProductionServer(options: ProductionServerOptions = {}): Promise<void> {
+  const cwd = process.cwd();
+  const routesDir = resolve(cwd, options.routesDir ?? "server/routes");
+  const staticDir = resolve(cwd, options.staticDir ?? "dist");
+  const port = options.port ?? Number(process.env.PORT ?? 3000);
+  const hostname = options.hostname ?? "0.0.0.0";
+
+  const loadHandler = async (filePath: string) => {
+    const mod = await import(pathToFileURL(filePath).href);
+    return mod as { default: FlowHandler };
+  };
+
+  const { dispatch, matches } = await createFlowServer(routesDir, loadHandler);
+  const apiMiddleware = flowServerMiddleware(dispatch, matches);
+
+  const server = createServer((req, res) => {
+    if (matches(req.url?.split("?")[0] ?? "/", req.method ?? "GET")) {
+      return apiMiddleware(req, res, () => serveStatic(req, res));
+    }
+    serveStatic(req, res);
+  });
+
+  function serveStatic(req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse) {
+    const path = (req.url ?? "/").split("?")[0] || "/";
+    const file = path === "/" ? "index.html" : path;
+    const filePath = join(staticDir, file.replace(/^\//, ""));
+    const stream = existsSync(filePath)
+      ? createReadStream(filePath)
+      : existsSync(join(staticDir, "index.html"))
+        ? createReadStream(join(staticDir, "index.html"))
+        : null;
+    if (stream) {
+      stream.on("error", () => { res.writeHead(404); res.end(); }).pipe(res);
+    } else {
+      res.writeHead(404);
+      res.end();
+    }
+  }
+
+  server.listen(port, hostname, () => {
+    console.log(`http://${hostname}:${port}`);
+  });
+}

package/src/route.ts

@@ -0,0 +1,15 @@
+export type FlowRequest = Request & { params: Record<string, string> };
+
+export type FlowHandler = (
+  request: FlowRequest
+) => Response | Promise<Response> | object | Promise<object>;
+
+export function Route(fn: FlowHandler): FlowHandler {
+  return async (request: FlowRequest) => {
+    const out = await fn(request);
+    if (out instanceof Response) return out;
+    return new Response(JSON.stringify(out), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+  };
+}

package/src/router.ts

@@ -0,0 +1,196 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { FlowHandler, FlowRequest } from './route.js';
+
+type DirentLike = { name: string; isDirectory(): boolean; isFile(): boolean };
+
+const METHOD_SUFFIXES = [
+  '.get',
+  '.post',
+  '.put',
+  '.delete',
+  '.patch',
+  '.head',
+  '.options',
+] as const;
+
+export type RouteMeta = { path: string; method: string; filePath: string };
+
+type Segment = { type: 'literal' | 'param' | 'catch'; value: string };
+
+function parseSegment(segment: string): Segment | null {
+  const catchAll = segment.match(/^\[\.\.\.(\w+)\]$/);
+  if (catchAll) return { type: 'catch', value: catchAll[1] };
+  const param = segment.match(/^\[(\w+)\]$/);
+  if (param) return { type: 'param', value: param[1] };
+  return { type: 'literal', value: segment };
+}
+
+function segmentsToPattern(segments: string[]): string {
+  const parts: string[] = [];
+  let hasCatchAll = false;
+  for (const s of segments) {
+    if (hasCatchAll) break;
+    const seg = parseSegment(s);
+    if (!seg) continue;
+    if (seg.type === 'literal') parts.push(seg.value);
+    else if (seg.type === 'param') parts.push(':' + seg.value);
+    else if (seg.type === 'catch') {
+      parts.push('*' + seg.value);
+      hasCatchAll = true;
+    }
+  }
+  return '/' + parts.join('/');
+}
+
+/** Default method per file senza suffisso (.get, .post, ecc.): tutte POST */
+const DEFAULT_METHOD = 'POST';
+
+function parseRoutePath(relativePath: string): { path: string; method: string } | null {
+  const lower = relativePath.toLowerCase();
+  const ext = lower.endsWith('.tsx') ? '.tsx' : '.ts';
+  for (const suffix of METHOD_SUFFIXES) {
+    if (lower.endsWith(suffix + ext)) {
+      const withoutExt = relativePath.slice(0, -(suffix.length + ext.length));
+      const segments = withoutExt.split(/[/\\]/).filter(Boolean);
+      const path = segmentsToPattern(segments);
+      const pathNorm = path === '/index' ? '/' : path;
+      const method = suffix.slice(1).toUpperCase();
+      return { path: pathNorm, method };
+    }
+  }
+  // File senza suffisso (api.ts, users.ts): POST
+  if (lower.endsWith(ext)) {
+    const withoutExt = relativePath.slice(0, -ext.length);
+    const segments = withoutExt.split(/[/\\]/).filter(Boolean);
+    const path = segmentsToPattern(segments);
+    const pathNorm = path === '/index' ? '/' : path;
+    return { path: pathNorm, method: DEFAULT_METHOD };
+  }
+  return null;
+}
+
+export async function walkRoutes(dir: string, base = ''): Promise<RouteMeta[]> {
+  let entries: DirentLike[];
+  try {
+    entries = (await readdir(dir, { withFileTypes: true })) as DirentLike[];
+  } catch {
+    return [];
+  }
+  const routes: RouteMeta[] = [];
+  for (const e of entries) {
+    const name = String(e.name);
+    const rel = base ? `${base}/${name}` : name;
+    if (e.isDirectory()) {
+      routes.push(...(await walkRoutes(join(dir, name), rel)));
+    } else if (e.isFile() && (name.endsWith('.ts') || name.endsWith('.tsx'))) {
+      const parsed = parseRoutePath(rel);
+      if (parsed) routes.push({ ...parsed, filePath: join(dir, name) });
+    }
+  }
+  return routes;
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function routePatternToRegex(path: string): { re: RegExp; keys: string[] } {
+  const keys: string[] = [];
+  const parts = path.split('/').filter(Boolean);
+  const pattern =
+    '^/' +
+    parts
+      .map((seg) => {
+        if (seg.startsWith('*')) {
+          keys.push(seg.slice(1));
+          return '(.+)';
+        }
+        if (seg.startsWith(':')) {
+          keys.push(seg.slice(1));
+          return '([^/]+)';
+        }
+        return escapeRegex(seg);
+      })
+      .join('/') +
+    '$';
+  return { re: new RegExp(pattern), keys };
+}
+
+export type LoadHandler = (filePath: string) => Promise<{ default: FlowHandler }>;
+
+type RouteEntry = {
+  method: string;
+  re: RegExp;
+  keys: string[];
+  handler: FlowHandler;
+};
+
+export async function createFlowServer(
+  routesDir: string,
+  loadHandler: LoadHandler
+): Promise<{
+  dispatch: (pathname: string, method: string, request: Request) => Promise<Response | null>;
+  matches: (pathname: string, method: string) => boolean;
+}> {
+  const routeList = await walkRoutes(routesDir);
+  const routes: RouteEntry[] = [];
+
+  for (const r of routeList) {
+    try {
+      const mod = await loadHandler(r.filePath);
+      const handler = mod.default;
+      if (!handler) continue;
+      const { re, keys } = routePatternToRegex(r.path);
+      routes.push({ method: r.method, re, keys, handler });
+    } catch (err) {
+      console.warn(`[flow-os:router] skip route ${r.filePath}:`, err);
+    }
+  }
+
+  function getMatch(
+    pathname: string,
+    method: string
+  ): { handler: FlowHandler; params: Record<string, string> } | null {
+    const norm = pathname.split('?')[0] || '/';
+    for (const route of routes) {
+      if (route.method !== method) continue;
+      const m = route.re.exec(norm);
+      if (!m) continue;
+      const params: Record<string, string> = {};
+      route.keys.forEach((k, i) => (params[k] = m[i + 1] ?? ''));
+      return { handler: route.handler, params };
+    }
+    return null;
+  }
+
+  async function dispatch(
+    pathname: string,
+    method: string,
+    request: Request
+  ): Promise<Response | null> {
+    const match = getMatch(pathname, method);
+    if (!match) return null;
+    try {
+      const flowReq = request as FlowRequest;
+      flowReq.params = match.params;
+      const out = await match.handler(flowReq);
+      if (out instanceof Response) return out;
+      return new Response(JSON.stringify(out), {
+        headers: { 'Content-Type': 'application/json' },
+      });
+    } catch (err) {
+      console.error('[flow-os:router] handler error:', err);
+      return new Response(
+        JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
+        { status: 500, headers: { 'Content-Type': 'application/json' } }
+      );
+    }
+  }
+
+  function matches(pathname: string, method: string): boolean {
+    return getMatch(pathname, method) !== null;
+  }
+
+  return { dispatch, matches };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "types": ["bun-types", "node"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"]
+}