@tamayrp14/fire-api 0.0.0-stage → 1.0.1

package/src/cli/routes.ts

@@ -0,0 +1,76 @@
+import { Router } from '../core/router';
+
+export interface RouteTableRow {
+  method: string;
+  path: string;
+  auth: string;
+  roles: string;
+  cache: string;
+  idempotent: string;
+  description: string;
+}
+
+export function formatRoutesTable(router: Router): string {
+  const routes = router.getRoutes();
+
+  if (routes.length === 0) {
+    return 'No routes registered in application.';
+  }
+
+  const rows: RouteTableRow[] = routes.map((r) => {
+    const roles = r.options.roles && r.options.roles.length > 0 ? r.options.roles.join(', ') : '-';
+    const cache = r.options.cache ? `${r.options.cache.ttl}s` : '-';
+    const idempotent = r.options.idempotent ? '✓' : '-';
+    const auth = r.options.security ? 'Required' : (r.options.roles ? 'Role-Guarded' : 'Public');
+    const description = r.options.ai?.description || '-';
+
+    return {
+      method: r.method,
+      path: r.path,
+      auth,
+      roles,
+      cache,
+      idempotent,
+      description,
+    };
+  });
+
+  // Calculate column widths
+  const headers = {
+    method: 'METHOD',
+    path: 'ROUTE PATH',
+    auth: 'AUTH',
+    roles: 'ROLES',
+    cache: 'CACHE',
+    idempotent: 'IDEMPOTENT',
+    description: 'DESCRIPTION',
+  };
+
+  const colWidths = {
+    method: Math.max(headers.method.length, ...rows.map((r) => r.method.length)),
+    path: Math.max(headers.path.length, ...rows.map((r) => r.path.length)),
+    auth: Math.max(headers.auth.length, ...rows.map((r) => r.auth.length)),
+    roles: Math.max(headers.roles.length, ...rows.map((r) => r.roles.length)),
+    cache: Math.max(headers.cache.length, ...rows.map((r) => r.cache.length)),
+    idempotent: Math.max(headers.idempotent.length, ...rows.map((r) => r.idempotent.length)),
+    description: Math.max(headers.description.length, ...rows.map((r) => r.description.length)),
+  };
+
+  const pad = (str: string, len: number) => str.padEnd(len, ' ');
+
+  const headerLine = `| ${pad(headers.method, colWidths.method)} | ${pad(headers.path, colWidths.path)} | ${pad(headers.auth, colWidths.auth)} | ${pad(headers.roles, colWidths.roles)} | ${pad(headers.cache, colWidths.cache)} | ${pad(headers.idempotent, colWidths.idempotent)} | ${pad(headers.description, colWidths.description)} |`;
+  const sepLine = `|-${'-'.repeat(colWidths.method)}-|-${'-'.repeat(colWidths.path)}-|-${'-'.repeat(colWidths.auth)}-|-${'-'.repeat(colWidths.roles)}-|-${'-'.repeat(colWidths.cache)}-|-${'-'.repeat(colWidths.idempotent)}-|-${'-'.repeat(colWidths.description)}-|`;
+
+  const bodyLines = rows.map((r) =>
+    `| ${pad(r.method, colWidths.method)} | ${pad(r.path, colWidths.path)} | ${pad(r.auth, colWidths.auth)} | ${pad(r.roles, colWidths.roles)} | ${pad(r.cache, colWidths.cache)} | ${pad(r.idempotent, colWidths.idempotent)} | ${pad(r.description, colWidths.description)} |`
+  );
+
+  return [
+    `🔥 FireAPI Route Manifest (${routes.length} total endpoints):`,
+    sepLine,
+    headerLine,
+    sepLine,
+    ...bodyLines,
+    sepLine,
+  ].join('\n');
+}

package/src/client.ts

@@ -0,0 +1,120 @@
+export interface ClientRequestOptions {
+  params?: Record<string, string | number>;
+  query?: Record<string, any>;
+  body?: any;
+  headers?: HeadersInit;
+}
+
+export interface ClientResponse<T = any> {
+  ok: boolean;
+  status: number;
+  data: T;
+  error?: any;
+  headers: Headers;
+}
+
+export interface ClientOptions {
+  fetch?: typeof fetch;
+  headers?: HeadersInit;
+}
+
+const HTTP_METHODS = new Set(['get', 'post', 'put', 'patch', 'delete', 'options', 'head']);
+
+function buildUrl(baseUrl: string, segments: string[], options?: ClientRequestOptions): string {
+  let path = segments.join('/');
+
+  // Substitute path params if any segment is :param or contains :param
+  if (options?.params) {
+    for (const [key, val] of Object.entries(options.params)) {
+      path = path.replace(new RegExp(`:${key}\\b`, 'g'), encodeURIComponent(String(val)));
+    }
+  }
+
+  // Remove any remaining raw :param if not replaced
+  const cleanBase = baseUrl.replace(/\/+$/, '');
+  const cleanPath = path.startsWith('/') ? path : '/' + path;
+  let fullUrl = `${cleanBase}${cleanPath}`;
+
+  if (options?.query) {
+    const searchParams = new URLSearchParams();
+    for (const [k, v] of Object.entries(options.query)) {
+      if (v !== undefined && v !== null) {
+        if (Array.isArray(v)) {
+          v.forEach((item) => searchParams.append(k, String(item)));
+        } else {
+          searchParams.append(k, String(v));
+        }
+      }
+    }
+    const queryStr = searchParams.toString();
+    if (queryStr) {
+      fullUrl += (fullUrl.includes('?') ? '&' : '?') + queryStr;
+    }
+  }
+
+  return fullUrl;
+}
+
+export function createClient<TApp = any>(baseUrl = '', clientOptions: ClientOptions = {}): any {
+  const fetchFn = clientOptions.fetch || globalThis.fetch;
+
+  function createProxy(pathSegments: string[]): any {
+    return new Proxy(() => {}, {
+      get(_target, prop: string) {
+        const lowerProp = prop.toLowerCase();
+        if (HTTP_METHODS.has(lowerProp)) {
+          // This is the terminal HTTP method call, e.g. .get({ params, query, body })
+          return async (reqOptions?: ClientRequestOptions): Promise<ClientResponse> => {
+            const url = buildUrl(baseUrl, pathSegments, reqOptions);
+            const headers = new Headers(clientOptions.headers);
+            if (reqOptions?.headers) {
+              const extraHeaders = new Headers(reqOptions.headers);
+              extraHeaders.forEach((v, k) => headers.set(k, v));
+            }
+
+            let bodyContent: BodyInit | undefined;
+            if (reqOptions?.body !== undefined && lowerProp !== 'get' && lowerProp !== 'head') {
+              if (!headers.has('Content-Type')) {
+                headers.set('Content-Type', 'application/json');
+              }
+              bodyContent = typeof reqOptions.body === 'string'
+                ? reqOptions.body
+                : JSON.stringify(reqOptions.body);
+            }
+
+            const response = await fetchFn(url, {
+              method: lowerProp.toUpperCase(),
+              headers,
+              body: bodyContent,
+            });
+
+            let responseData: any = null;
+            const contentType = response.headers.get('content-type') || '';
+            if (contentType.includes('application/json')) {
+              try {
+                responseData = await response.json();
+              } catch {
+                responseData = null;
+              }
+            } else {
+              responseData = await response.text();
+            }
+
+            return {
+              ok: response.ok,
+              status: response.status,
+              data: responseData,
+              error: response.ok ? undefined : responseData,
+              headers: response.headers,
+            };
+          };
+        }
+
+        // Sub-path traversal
+        return createProxy([...pathSegments, prop]);
+      },
+    });
+  }
+
+  return createProxy([]);
+}

package/src/compat/express.ts

@@ -0,0 +1,139 @@
+import { Middleware } from '../types';
+
+export type ExpressMiddleware = (
+  req: any,
+  res: any,
+  next: (err?: any) => void
+) => void | Promise<void>;
+
+export function fromExpress(expressMiddleware: ExpressMiddleware): Middleware {
+  return async (ctx, next) => {
+    let statusCode = 200;
+    const responseHeaders = new Headers();
+    let earlyResponse: Response | null = null;
+    let nextCalled = false;
+
+    // Use a clean proxy to avoid assigning to readonly properties on native Request
+    const customProps: Record<string, any> = {
+      url: new URL(ctx.req.url).pathname,
+      path: new URL(ctx.req.url).pathname,
+      method: ctx.req.method,
+      headers: Object.fromEntries(ctx.req.headers.entries()),
+      params: ctx.params,
+      query: ctx.query,
+      body: ctx.body,
+    };
+
+    const simulatedReq = new Proxy(ctx.req, {
+      get(target, prop: string) {
+        if (prop in customProps) {
+          return customProps[prop];
+        }
+        const val = (target as any)[prop];
+        return typeof val === 'function' ? val.bind(target) : val;
+      },
+      set(_target, prop: string, value: any) {
+        customProps[prop] = value;
+        return true;
+      },
+      has(_target, prop: string) {
+        return prop in customProps || prop in _target;
+      },
+    });
+
+    // Point ctx.req to proxy so handlers have access to properties attached by Express middleware
+    (ctx as any).req = simulatedReq;
+
+    // Simulated Express res
+    const simulatedRes: any = {
+      statusCode: 200,
+      setHeader(name: string, value: string) {
+        responseHeaders.set(name, value);
+        return this;
+      },
+      getHeader(name: string) {
+        return responseHeaders.get(name);
+      },
+      removeHeader(name: string) {
+        responseHeaders.delete(name);
+        return this;
+      },
+      status(code: number) {
+        statusCode = code;
+        this.statusCode = code;
+        return this;
+      },
+      json(data: any) {
+        responseHeaders.set('Content-Type', 'application/json');
+        earlyResponse = new Response(JSON.stringify(data), {
+          status: statusCode,
+          headers: responseHeaders,
+        });
+        return this;
+      },
+      send(body: any) {
+        if (typeof body === 'object' && body !== null) {
+          return this.json(body);
+        }
+        if (!responseHeaders.has('Content-Type')) {
+          responseHeaders.set('Content-Type', 'text/html; charset=utf-8');
+        }
+        earlyResponse = new Response(String(body ?? ''), {
+          status: statusCode,
+          headers: responseHeaders,
+        });
+        return this;
+      },
+      end(chunk?: any) {
+        if (chunk) {
+          return this.send(chunk);
+        }
+        earlyResponse = new Response(null, {
+          status: statusCode,
+          headers: responseHeaders,
+        });
+        return this;
+      },
+    };
+
+    return new Promise<Response>((resolve, reject) => {
+      try {
+        const nextFn = async (err?: any) => {
+          nextCalled = true;
+          if (err) {
+            reject(err);
+            return;
+          }
+          try {
+            const downstreamResponse = await next();
+            const mergedHeaders = new Headers(downstreamResponse.headers);
+            responseHeaders.forEach((v, k) => mergedHeaders.set(k, v));
+
+            resolve(
+              new Response(downstreamResponse.body, {
+                status: downstreamResponse.status,
+                statusText: downstreamResponse.statusText,
+                headers: mergedHeaders,
+              })
+            );
+          } catch (e) {
+            reject(e);
+          }
+        };
+
+        const result = expressMiddleware(simulatedReq, simulatedRes, nextFn);
+
+        if (result && typeof (result as any).catch === 'function') {
+          (result as any).catch(reject);
+        }
+
+        // Check if response was sent synchronously without calling next()
+        if (!nextCalled && earlyResponse) {
+          resolve(earlyResponse);
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+  };
+}