@tamayrp14/fire-api 0.0.0-stage → 1.0.1

package/src/core/context.ts

@@ -0,0 +1,218 @@
+import { FireCacheManager, FireContext, FireDatabase, FireQueue, FireStorage, UploadedFile } from '../types';
+import { HttpError } from './error';
+import { createSSEResponse } from '../stream/sse';
+import { WebhookVerifier } from '../shield/webhook';
+import { FireLogger } from '../logging/logger';
+
+function parseQuery(urlStr: string): Record<string, string | string[]> {
+  const url = new URL(urlStr, 'http://localhost');
+  const query: Record<string, string | string[]> = {};
+  url.searchParams.forEach((val, key) => {
+    if (key in query) {
+      if (Array.isArray(query[key])) {
+        (query[key] as string[]).push(val);
+      } else {
+        query[key] = [query[key] as string, val];
+      }
+    } else {
+      query[key] = val;
+    }
+  });
+  return query;
+}
+
+const dummyDb: FireDatabase = {
+  table() {
+    throw new Error('Database not initialized. Configure database in createApp({ database: ... })');
+  },
+  async raw() {
+    throw new Error('Database not initialized');
+  },
+  async transaction() {
+    throw new Error('Database not initialized');
+  },
+  async tx() {
+    throw new Error('Database not initialized');
+  },
+  async seed() {
+    throw new Error('Database not initialized');
+  },
+};
+
+const dummyCache: FireCacheManager = {
+  async get() { return null; },
+  async set() {},
+  async invalidate() {},
+  async clear() {},
+};
+
+const dummyQueue: FireQueue = {
+  async dispatch(name, data) {
+    return {
+      id: 'dummy',
+      name,
+      data,
+      attempts: 0,
+      maxAttempts: 1,
+      createdAt: Date.now(),
+      status: 'pending',
+    };
+  },
+  handle() {},
+};
+
+const dummyStorage: FireStorage = {
+  async put(path, content) {
+    const size = typeof content === 'string' ? content.length : (content as Uint8Array).byteLength || 0;
+    return { path, url: `/uploads/${path}`, size };
+  },
+  async get() { return null; },
+  async getText() { return null; },
+  async delete() { return true; },
+  async exists() { return false; },
+  url(path) { return `/uploads/${path}`; },
+};
+
+export interface CreateContextOptions {
+  req: Request;
+  params?: Record<string, string>;
+  db?: FireDatabase;
+  cache?: FireCacheManager;
+  queue?: FireQueue;
+  storage?: FireStorage;
+  user?: any;
+  body?: any;
+  files?: Record<string, UploadedFile>;
+  rawBody?: string;
+  requestId?: string;
+  traceId?: string;
+  logger?: any;
+  tenant?: { id: string; [key: string]: any };
+  emit?: (event: string, payload?: any) => Promise<void>;
+}
+
+export function createContext(opts: CreateContextOptions): FireContext {
+  const {
+    req,
+    params = {},
+    db = dummyDb,
+    cache = dummyCache,
+    queue = dummyQueue,
+    storage = dummyStorage,
+    user = null,
+    body = null,
+    files = {},
+    rawBody = '',
+    emit,
+  } = opts;
+  const query = parseQuery(req.url);
+  const state: Record<string, any> = {};
+  const webhookVerifier = new WebhookVerifier(req, rawBody);
+  const requestId = opts.requestId || req.headers.get('x-request-id') || `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  const traceId = opts.traceId || req.headers.get('traceparent') || undefined;
+  const log = opts.logger || new FireLogger(requestId);
+
+  const ctx: FireContext = {
+    req,
+    params,
+    query,
+    body,
+    files,
+    user,
+    db,
+    cache,
+    queue,
+    storage,
+    state,
+    rawBody,
+    requestId,
+    traceId,
+    log,
+    tenant: opts.tenant,
+
+    emit: async (event: string, payload?: any) => {
+      if (emit) {
+        await emit(event, payload);
+      }
+    },
+
+    webhook: {
+      verifyHMAC: (options) => webhookVerifier.verifyHMAC(options),
+    },
+
+    stream: {
+      sse(handler) {
+        return createSSEResponse(handler);
+      },
+    },
+
+    earlyHints(links: string[]) {
+      if (!ctx.state.earlyHints) {
+        ctx.state.earlyHints = [];
+      }
+      ctx.state.earlyHints.push(...links);
+    },
+
+    json(data: any, status = 200, headers?: HeadersInit): Response {
+      const respHeaders = new Headers(headers);
+      if (!respHeaders.has('Content-Type')) {
+        respHeaders.set('Content-Type', 'application/json; charset=utf-8');
+      }
+      return new Response(JSON.stringify(data), {
+        status,
+        headers: respHeaders,
+      });
+    },
+
+    ok(data: any): Response {
+      return ctx.json(data, 200);
+    },
+
+    created(data: any): Response {
+      return ctx.json(data, 201);
+    },
+
+    noContent(): Response {
+      return new Response(null, { status: 204 });
+    },
+
+    badRequest(errors: any): Response {
+      const msg = typeof errors === 'string' ? errors : (errors?.message || 'Bad Request');
+      return new HttpError(400, msg, errors).toResponse();
+    },
+
+    unauthorized(message = 'Unauthorized'): Response {
+      return new HttpError(401, message).toResponse();
+    },
+
+    forbidden(message = 'Forbidden'): Response {
+      return new HttpError(403, message).toResponse();
+    },
+
+    notFound(message = 'Not Found'): Response {
+      return new HttpError(404, message).toResponse();
+    },
+
+    internalError(message = 'Internal Server Error'): Response {
+      return new HttpError(500, message).toResponse();
+    },
+
+    text(content: string, status = 200, headers?: HeadersInit): Response {
+      const respHeaders = new Headers(headers);
+      if (!respHeaders.has('Content-Type')) {
+        respHeaders.set('Content-Type', 'text/plain; charset=utf-8');
+      }
+      return new Response(content, { status, headers: respHeaders });
+    },
+
+    html(content: string, status = 200, headers?: HeadersInit): Response {
+      const respHeaders = new Headers(headers);
+      if (!respHeaders.has('Content-Type')) {
+        respHeaders.set('Content-Type', 'text/html; charset=utf-8');
+      }
+      return new Response(content, { status, headers: respHeaders });
+    },
+  };
+
+  return ctx;
+}

package/src/core/error.ts

@@ -0,0 +1,42 @@
+export class HttpError extends Error {
+  public statusCode: number;
+  public details?: any;
+
+  constructor(statusCode: number, message: string, details?: any) {
+    super(message);
+    this.name = 'HttpError';
+    this.statusCode = statusCode;
+    this.details = details;
+    Object.setPrototypeOf(this, HttpError.prototype);
+  }
+
+  public getStatusText(): string {
+    switch (this.statusCode) {
+      case 400: return 'Bad Request';
+      case 401: return 'Unauthorized';
+      case 403: return 'Forbidden';
+      case 404: return 'Not Found';
+      case 405: return 'Method Not Allowed';
+      case 409: return 'Conflict';
+      case 422: return 'Unprocessable Entity';
+      case 429: return 'Too Many Requests';
+      case 500: return 'Internal Server Error';
+      default: return 'Error';
+    }
+  }
+
+  public toResponse(): Response {
+    const payload: Record<string, any> = {
+      statusCode: this.statusCode,
+      error: this.getStatusText(),
+      message: this.message,
+    };
+    if (this.details !== undefined) {
+      payload.details = this.details;
+    }
+    return new Response(JSON.stringify(payload), {
+      status: this.statusCode,
+      headers: { 'Content-Type': 'application/json; charset=utf-8' },
+    });
+  }
+}

package/src/core/router.ts

@@ -0,0 +1,262 @@
+import { Handler, HttpMethod, Middleware, RouteMatch, RouteOptions } from '../types';
+
+interface RadixNode {
+  part: string;
+  isParam: boolean;
+  paramName?: string;
+  isWildcard: boolean;
+  children: Map<string, RadixNode>;
+  paramChild?: RadixNode;
+  wildcardChild?: RadixNode;
+  handlers: Map<HttpMethod, { options: RouteOptions; middlewares: Middleware[] }>;
+}
+
+function createNode(part = ''): RadixNode {
+  const isParam = part.startsWith(':');
+  const isWildcard = part === '*' || part.startsWith('*');
+  return {
+    part,
+    isParam,
+    paramName: isParam ? part.slice(1) : undefined,
+    isWildcard,
+    children: new Map(),
+    handlers: new Map(),
+  };
+}
+
+export function normalizePath(path: string): string {
+  if (!path || path === '/' || path === '') return '/';
+  let clean = path.replace(/\/+/g, '/');
+  if (clean.length > 1 && clean.endsWith('/')) {
+    clean = clean.slice(0, -1);
+  }
+  if (!clean.startsWith('/')) {
+    clean = '/' + clean;
+  }
+  return clean;
+}
+
+export class Router {
+  private root: RadixNode = createNode();
+  public middlewares: Middleware[] = [];
+  public prefix: string;
+  public routesList: { method: HttpMethod; path: string; options: RouteOptions }[] = [];
+  private fastPathCache: Map<string, RouteMatch> = new Map();
+  private maxFastPathEntries = 2000;
+
+  constructor(prefix = '') {
+    this.prefix = prefix ? normalizePath(prefix) : '';
+  }
+
+  public use(middleware: Middleware): this;
+  public use(subRouter: Router): this;
+  public use(prefix: string, subRouter: Router): this;
+  public use(arg1: string | Middleware | Router, arg2?: Router): this {
+    if (typeof arg1 === 'function') {
+      this.middlewares.push(arg1);
+      return this;
+    }
+
+    if (arg1 instanceof Router) {
+      for (const route of arg1.routesList) {
+        const fullPath = this.prefix && !route.path.startsWith(this.prefix)
+          ? normalizePath(`${this.prefix}/${route.path}`)
+          : route.path;
+        const combinedMiddlewares = [...arg1.middlewares, ...(route.options.middlewares || [])];
+        this.addRawRoute(route.method, fullPath, {
+          ...route.options,
+          middlewares: combinedMiddlewares,
+        });
+      }
+      return this;
+    }
+
+    if (typeof arg1 === 'string' && arg2 instanceof Router) {
+      const subPrefix = normalizePath(arg1);
+      for (const route of arg2.routesList) {
+        const fullPath = route.path.startsWith(subPrefix)
+          ? route.path
+          : normalizePath(`${subPrefix}/${route.path}`);
+        const combinedMiddlewares = [...arg2.middlewares, ...(route.options.middlewares || [])];
+        this.addRawRoute(route.method, fullPath, {
+          ...route.options,
+          middlewares: combinedMiddlewares,
+        });
+      }
+      return this;
+    }
+
+    return this;
+  }
+
+  public addRoute(method: HttpMethod, path: string, options: RouteOptions): this {
+    let cleanPath = normalizePath(path);
+    if (this.prefix && !cleanPath.startsWith(this.prefix)) {
+      cleanPath = normalizePath(`${this.prefix}/${cleanPath}`);
+    }
+    return this.addRawRoute(method, cleanPath, options);
+  }
+
+  private addRawRoute(method: HttpMethod, fullPath: string, options: RouteOptions): this {
+    this.routesList.push({ method, path: fullPath, options });
+
+    const parts = fullPath.split('/').filter(Boolean);
+    let current = this.root;
+
+    for (const part of parts) {
+      if (part === '*' || part.startsWith('*')) {
+        if (!current.wildcardChild) {
+          current.wildcardChild = createNode(part);
+        }
+        current = current.wildcardChild;
+        break; // Wildcard absorbs remainder
+      } else if (part.startsWith(':')) {
+        if (!current.paramChild) {
+          current.paramChild = createNode(part);
+        }
+        current = current.paramChild;
+      } else {
+        if (!current.children.has(part)) {
+          current.children.set(part, createNode(part));
+        }
+        current = current.children.get(part)!;
+      }
+    }
+
+    const routeMiddlewares = options.middlewares || [];
+    current.handlers.set(method, {
+      options,
+      middlewares: [...this.middlewares, ...routeMiddlewares],
+    });
+
+    return this;
+  }
+
+  private resolveOptions(optionsOrHandler: RouteOptions | Handler): RouteOptions {
+    if (typeof optionsOrHandler === 'function') {
+      return { handler: optionsOrHandler };
+    }
+    return optionsOrHandler;
+  }
+
+  public get(path: string, optionsOrHandler: RouteOptions | Handler): this {
+    return this.addRoute('GET', path, this.resolveOptions(optionsOrHandler));
+  }
+
+  public post(path: string, optionsOrHandler: RouteOptions | Handler): this {
+    return this.addRoute('POST', path, this.resolveOptions(optionsOrHandler));
+  }
+
+  public put(path: string, optionsOrHandler: RouteOptions | Handler): this {
+    return this.addRoute('PUT', path, this.resolveOptions(optionsOrHandler));
+  }
+
+  public patch(path: string, optionsOrHandler: RouteOptions | Handler): this {
+    return this.addRoute('PATCH', path, this.resolveOptions(optionsOrHandler));
+  }
+
+  public delete(path: string, optionsOrHandler: RouteOptions | Handler): this {
+    return this.addRoute('DELETE', path, this.resolveOptions(optionsOrHandler));
+  }
+
+  public options(path: string, optionsOrHandler: RouteOptions | Handler): this {
+    return this.addRoute('OPTIONS', path, this.resolveOptions(optionsOrHandler));
+  }
+
+  public head(path: string, optionsOrHandler: RouteOptions | Handler): this {
+    return this.addRoute('HEAD', path, this.resolveOptions(optionsOrHandler));
+  }
+
+  public match(method: HttpMethod, rawPath: string): RouteMatch | null {
+    const cleanPath = normalizePath(rawPath);
+    const cacheKey = `${method}:${cleanPath}`;
+
+    const cached = this.fastPathCache.get(cacheKey);
+    if (cached) {
+      return {
+        handler: cached.handler,
+        routeOptions: cached.routeOptions,
+        params: { ...cached.params },
+        middlewares: cached.middlewares,
+      };
+    }
+
+    const parts = cleanPath.split('/').filter(Boolean);
+    const params: Record<string, string> = {};
+
+    const result = this.searchNode(this.root, parts, 0, method, params);
+    if (!result) return null;
+
+    const matched: RouteMatch = {
+      handler: result.options.handler,
+      routeOptions: result.options,
+      params,
+      middlewares: result.middlewares,
+    };
+
+    if (this.fastPathCache.size >= this.maxFastPathEntries) {
+      const keys = Array.from(this.fastPathCache.keys()).slice(0, 400);
+      for (const k of keys) this.fastPathCache.delete(k);
+    }
+    this.fastPathCache.set(cacheKey, matched);
+
+    return {
+      ...matched,
+      params: { ...matched.params },
+    };
+  }
+
+  private searchNode(
+    node: RadixNode,
+    parts: string[],
+    index: number,
+    method: HttpMethod,
+    params: Record<string, string>
+  ): { options: RouteOptions; middlewares: Middleware[] } | null {
+    if (index >= parts.length) {
+      const handlerData = node.handlers.get(method);
+      if (handlerData) return handlerData;
+      if (node.wildcardChild && node.wildcardChild.handlers.has(method)) {
+        params['*'] = '';
+        return node.wildcardChild.handlers.get(method)!;
+      }
+      return null;
+    }
+
+    const part = parts[index];
+
+    // 1. Static match
+    const staticChild = node.children.get(part);
+    if (staticChild) {
+      const match = this.searchNode(staticChild, parts, index + 1, method, params);
+      if (match) return match;
+    }
+
+    // 2. Param match
+    if (node.paramChild) {
+      const match = this.searchNode(node.paramChild, parts, index + 1, method, params);
+      if (match) {
+        if (node.paramChild.paramName) {
+          params[node.paramChild.paramName] = decodeURIComponent(part);
+        }
+        return match;
+      }
+    }
+
+    // 3. Wildcard match
+    if (node.wildcardChild && node.wildcardChild.handlers.has(method)) {
+      params['*'] = parts.slice(index).map(decodeURIComponent).join('/');
+      return node.wildcardChild.handlers.get(method)!;
+    }
+
+    return null;
+  }
+
+  public getRoutes(): Array<{ method: HttpMethod; path: string; options: RouteOptions }> {
+    return this.routesList;
+  }
+}
+
+export function createRouter(prefix = ''): Router {
+  return new Router(prefix);
+}

package/src/db/db-interface.ts

@@ -0,0 +1,9 @@
+import { FireDatabase, QueryBuilder } from '../types';
+
+export type { FireDatabase, QueryBuilder };
+
+export interface WhereClause {
+  field: string;
+  operator: '=' | '!=' | '>' | '>=' | '<' | '<=' | 'like' | 'in';
+  value: any;
+}