@tamayrp14/fire-api 0.0.0-stage → 1.0.0

package/src/db/hub.ts

@@ -0,0 +1,256 @@
+import { FireDatabase, FireDatabaseOptions, QueryBuilder, TableModel } from '../types';
+import { MemoryDatabase } from './memory-adapter';
+import { SQLiteDatabase } from './sqlite-adapter';
+import { generateMock } from '../schema/mock';
+
+function toSingular(name: string): string {
+  if (name.endsWith('ies')) return name.slice(0, -3) + 'y';
+  if (name.endsWith('es') && !name.endsWith('ses')) return name.slice(0, -2);
+  if (name.endsWith('s') && !name.endsWith('ss')) return name.slice(0, -1);
+  return name;
+}
+
+function toPlural(name: string): string {
+  if (name.endsWith('y') && !/[aeiou]y$/i.test(name)) return name.slice(0, -1) + 'ies';
+  if (name.endsWith('s')) return name;
+  return name + 's';
+}
+
+async function attachRelations(
+  db: FireDatabase,
+  parentTableName: string,
+  rows: Record<string, any>[],
+  relations: string[]
+): Promise<void> {
+  if (!rows || rows.length === 0 || !relations || relations.length === 0) return;
+
+  const parentSingular = toSingular(parentTableName);
+  const possibleParentFkNames = [
+    `${parentSingular}Id`,
+    `${parentSingular}_id`,
+    `${parentTableName}Id`,
+    `${parentTableName}_id`,
+  ];
+
+  for (const rel of relations) {
+    const isPluralRelation = rel.endsWith('s') || rel.endsWith('ies');
+    const relSingular = toSingular(rel);
+    const relPlural = toPlural(rel);
+    const candidateTableNames = [rel, relPlural, relSingular];
+
+    for (const row of rows) {
+      if (!row) continue;
+      let resolved = false;
+
+      // 1. Belongs-To / Many-to-One
+      const possibleFkInParent = [
+        `${relSingular}Id`,
+        `${relSingular}_id`,
+        `${rel}Id`,
+        `${rel}_id`,
+      ];
+
+      for (const fk of possibleFkInParent) {
+        if (row[fk] !== undefined && row[fk] !== null) {
+          for (const tbl of candidateTableNames) {
+            try {
+              const relatedItem = await db.table(tbl).findById(row[fk]);
+              if (relatedItem) {
+                row[rel] = relatedItem;
+                resolved = true;
+                break;
+              }
+            } catch {}
+          }
+          if (resolved) break;
+        }
+      }
+
+      if (resolved) continue;
+
+      // 2. Has-Many / One-to-Many
+      for (const tbl of candidateTableNames) {
+        let matchingChildren: any[] = [];
+        for (const parentFk of possibleParentFkNames) {
+          try {
+            const results = await db.table(tbl).where(parentFk, row.id).find();
+            if (results && results.length > 0) {
+              matchingChildren = results;
+              break;
+            }
+          } catch {}
+        }
+
+        if (matchingChildren.length > 0 || isPluralRelation) {
+          row[rel] = isPluralRelation ? matchingChildren : (matchingChildren[0] || null);
+          resolved = true;
+          break;
+        }
+      }
+
+      if (!resolved && isPluralRelation) {
+        row[rel] = [];
+      }
+    }
+  }
+}
+
+function createTableModel(
+  target: FireDatabase,
+  tableName: string,
+  includedRelations: string[] = [],
+  baseQb?: QueryBuilder,
+  tenantId?: string
+): TableModel {
+  const getQb = () => {
+    let qb = baseQb || target.table(tableName);
+    if (tenantId && !baseQb) {
+      qb = qb.where('tenantId', tenantId);
+    }
+    return qb;
+  };
+
+  const model: TableModel = {
+    include: (relation: string | string[]) => {
+      const rels = Array.isArray(relation) ? relation : [relation];
+      return createTableModel(target, tableName, [...includedRelations, ...rels], baseQb, tenantId);
+    },
+    where: (field: string, opOrVal: any, val?: any) => {
+      const newQb = getQb().where(field, opOrVal, val);
+      return createTableModel(target, tableName, includedRelations, newQb, tenantId);
+    },
+    limit: (count: number) => {
+      const newQb = getQb().limit(count);
+      return createTableModel(target, tableName, includedRelations, newQb, tenantId);
+    },
+    offset: (count: number) => {
+      const newQb = getQb().offset(count);
+      return createTableModel(target, tableName, includedRelations, newQb, tenantId);
+    },
+    orderBy: (field: string, direction?: 'asc' | 'desc') => {
+      const newQb = getQb().orderBy(field, direction);
+      return createTableModel(target, tableName, includedRelations, newQb, tenantId);
+    },
+    find: async (filter?: Record<string, any>) => {
+      let qb = getQb();
+      if (filter) {
+        for (const [k, v] of Object.entries(filter)) {
+          qb = qb.where(k, v);
+        }
+      }
+      const rows = await qb.find();
+      if (includedRelations.length > 0) {
+        await attachRelations(target, tableName, rows, includedRelations);
+      }
+      return rows;
+    },
+    findOne: async (filter?: Record<string, any>) => {
+      let qb = getQb();
+      if (filter) {
+        for (const [k, v] of Object.entries(filter)) {
+          qb = qb.where(k, v);
+        }
+      }
+      const row = await qb.findOne();
+      if (row && includedRelations.length > 0) {
+        await attachRelations(target, tableName, [row], includedRelations);
+      }
+      return row;
+    },
+    findById: async (id: string | number) => {
+      const row = await getQb().findById(id);
+      if (row && includedRelations.length > 0) {
+        await attachRelations(target, tableName, [row], includedRelations);
+      }
+      return row;
+    },
+    insert: (data: any) => {
+      if (tenantId) {
+        if (Array.isArray(data)) {
+          data = data.map((d) => ({ tenantId, ...d }));
+        } else if (typeof data === 'object' && data !== null) {
+          data = { tenantId, ...data };
+        }
+      }
+      return getQb().insert(data);
+    },
+    update: (idOrFilter: any, data?: any) => {
+      if (data === undefined) {
+        return getQb().update(idOrFilter);
+      }
+      return getQb().where('id', idOrFilter).update(data);
+    },
+    delete: (idOrFilter?: any) => {
+      if (idOrFilter === undefined) {
+        return getQb().delete();
+      }
+      if (typeof idOrFilter === 'string' || typeof idOrFilter === 'number') {
+        return getQb().where('id', idOrFilter).delete();
+      }
+      let qb = getQb();
+      for (const [k, v] of Object.entries(idOrFilter)) {
+        qb = qb.where(k, v);
+      }
+      return qb.delete();
+    },
+  };
+
+  return model;
+}
+
+export function createProxyDatabase(db: FireDatabase, options?: { tenantId?: string }): FireDatabase {
+  return new Proxy(db, {
+    get(target, prop: string) {
+      if (prop === 'seed') {
+        return async (tbl: string, schema: any, count = 10) => {
+          const items = Array.from({ length: count }, () => {
+            const mock = generateMock(schema);
+            if (options?.tenantId) {
+              mock.tenantId = options.tenantId;
+            }
+            return mock;
+          });
+          return target.table(tbl).insert(items);
+        };
+      }
+
+      if (prop === 'transaction' || prop === 'tx') {
+        return (fn: (trx: FireDatabase) => Promise<any>) => {
+          const rawTrxFn = (target.tx || target.transaction).bind(target);
+          return rawTrxFn((rawTrx: FireDatabase) => {
+            return fn(createProxyDatabase(rawTrx, options));
+          });
+        };
+      }
+
+      if (prop in target || typeof prop === 'symbol') {
+        const val = (target as any)[prop];
+        return typeof val === 'function' ? val.bind(target) : val;
+      }
+
+      // Dynamic table model access: ctx.db.products -> TableModel
+      return createTableModel(target, prop, [], undefined, options?.tenantId);
+    },
+  });
+}
+
+export function createDatabaseHub(options: FireDatabaseOptions = {}): FireDatabase {
+  const driver = options.driver || 'memory';
+  let rawDb: FireDatabase;
+
+  switch (driver) {
+    case 'sqlite':
+      rawDb = new SQLiteDatabase(options.url || ':memory:');
+      break;
+    case 'postgres':
+    case 'mysql':
+      rawDb = new MemoryDatabase();
+      break;
+    case 'memory':
+    default:
+      rawDb = new MemoryDatabase();
+      break;
+  }
+
+  return createProxyDatabase(rawDb);
+}

package/src/db/memory-adapter.ts

@@ -0,0 +1,202 @@
+import { FireDatabase, QueryBuilder } from '../types';
+import { WhereClause } from './db-interface';
+
+export class MemoryQueryBuilder implements QueryBuilder {
+  private clauses: WhereClause[] = [];
+  private limitCount?: number;
+  private offsetCount = 0;
+  private orderField?: string;
+  private orderDir: 'asc' | 'desc' = 'asc';
+
+  constructor(private storage: Map<string, Record<string, any>[]>, private tableName: string) {}
+
+  private getTableData(): Record<string, any>[] {
+    if (!this.storage.has(this.tableName)) {
+      this.storage.set(this.tableName, []);
+    }
+    return this.storage.get(this.tableName)!;
+  }
+
+  public where(field: string, operatorOrValue: any, value?: any): QueryBuilder {
+    if (value === undefined) {
+      this.clauses.push({ field, operator: '=', value: operatorOrValue });
+    } else {
+      this.clauses.push({ field, operator: operatorOrValue, value });
+    }
+    return this;
+  }
+
+  public limit(count: number): QueryBuilder {
+    this.limitCount = count;
+    return this;
+  }
+
+  public offset(count: number): QueryBuilder {
+    this.offsetCount = count;
+    return this;
+  }
+
+  public orderBy(field: string, direction: 'asc' | 'desc' = 'asc'): QueryBuilder {
+    this.orderField = field;
+    this.orderDir = direction;
+    return this;
+  }
+
+  public include(_relation: string | string[]): QueryBuilder {
+    return this;
+  }
+
+  private filterRows(): Record<string, any>[] {
+    let rows = [...this.getTableData()];
+
+    // Apply where clauses
+    for (const clause of this.clauses) {
+      rows = rows.filter((row) => {
+        const val = row[clause.field];
+        switch (clause.operator) {
+          case '=': return val === clause.value;
+          case '!=': return val !== clause.value;
+          case '>': return val > clause.value;
+          case '>=': return val >= clause.value;
+          case '<': return val < clause.value;
+          case '<=': return val <= clause.value;
+          case 'in': return Array.isArray(clause.value) && clause.value.includes(val);
+          case 'like':
+            return typeof val === 'string' &&
+              val.toLowerCase().includes(String(clause.value).toLowerCase().replace(/%/g, ''));
+          default: return val === clause.value;
+        }
+      });
+    }
+
+    // Apply order
+    if (this.orderField) {
+      const field = this.orderField;
+      const factor = this.orderDir === 'asc' ? 1 : -1;
+      rows.sort((a, b) => {
+        if (a[field] < b[field]) return -1 * factor;
+        if (a[field] > b[field]) return 1 * factor;
+        return 0;
+      });
+    }
+
+    // Apply pagination
+    if (this.offsetCount > 0) {
+      rows = rows.slice(this.offsetCount);
+    }
+    if (this.limitCount !== undefined) {
+      rows = rows.slice(0, this.limitCount);
+    }
+
+    return rows;
+  }
+
+  public async find<T = any>(): Promise<T[]> {
+    return this.filterRows() as T[];
+  }
+
+  public async findOne<T = any>(): Promise<T | null> {
+    const rows = this.filterRows();
+    return rows.length > 0 ? (rows[0] as T) : null;
+  }
+
+  public async findById<T = any>(id: string | number): Promise<T | null> {
+    const rows = this.getTableData().filter((r) => String(r.id) === String(id));
+    return rows.length > 0 ? (rows[0] as T) : null;
+  }
+
+  public async insert<T = any>(data: Record<string, any> | Record<string, any>[]): Promise<T> {
+    const table = this.getTableData();
+    if (Array.isArray(data)) {
+      const insertedList = data.map((item, idx) => ({
+        id: item.id || `mem_${Date.now()}_${idx}_${Math.random().toString(36).slice(2, 7)}`,
+        createdAt: new Date().toISOString(),
+        ...item,
+      }));
+      table.push(...insertedList);
+      return insertedList as any;
+    } else {
+      const inserted = {
+        id: data.id || `mem_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+        createdAt: new Date().toISOString(),
+        ...data,
+      };
+      table.push(inserted);
+      return inserted as any;
+    }
+  }
+
+  public async update<T = any>(data: Record<string, any>): Promise<T> {
+    const targetRows = this.filterRows();
+    if (targetRows.length === 0) {
+      return null as any;
+    }
+
+    const table = this.getTableData();
+    let lastUpdated: any = null;
+
+    for (const target of targetRows) {
+      const idx = table.findIndex((r) => r.id === target.id);
+      if (idx !== -1) {
+        table[idx] = {
+          ...table[idx],
+          ...data,
+          updatedAt: new Date().toISOString(),
+        };
+        lastUpdated = table[idx];
+      }
+    }
+
+    return lastUpdated as T;
+  }
+
+  public async delete(): Promise<{ count: number }> {
+    const targetRows = this.filterRows();
+    const table = this.getTableData();
+    const targetIds = new Set(targetRows.map((r) => r.id));
+
+    const remaining = table.filter((r) => !targetIds.has(r.id));
+    this.storage.set(this.tableName, remaining);
+
+    return { count: targetRows.length };
+  }
+}
+
+export class MemoryDatabase implements FireDatabase {
+  private storage: Map<string, Record<string, any>[]> = new Map();
+
+  public table(name: string): QueryBuilder {
+    return new MemoryQueryBuilder(this.storage, name);
+  }
+
+  public async raw<T = any>(_sql: string, _params?: any[]): Promise<T> {
+    return [] as any;
+  }
+
+  public async transaction<T>(fn: (trx: FireDatabase) => Promise<T>): Promise<T> {
+    // Deep snapshot of current storage for automatic rollback
+    const snapshot = new Map<string, Record<string, any>[]>();
+    for (const [table, rows] of this.storage.entries()) {
+      snapshot.set(table, rows.map((r) => ({ ...r })));
+    }
+
+    try {
+      return await fn(this);
+    } catch (err) {
+      // Rollback on any thrown error
+      this.storage.clear();
+      for (const [table, rows] of snapshot.entries()) {
+        this.storage.set(table, rows);
+      }
+      throw err;
+    }
+  }
+
+  public async tx<T>(fn: (trx: FireDatabase) => Promise<T>): Promise<T> {
+    return this.transaction(fn);
+  }
+
+  public clear(): void {
+    this.storage.clear();
+  }
+}

package/src/db/migrator.ts

@@ -0,0 +1,100 @@
+import { FireDatabase } from '../types';
+
+export interface Migration {
+  name: string;
+  up: (db: FireDatabase) => Promise<void>;
+  down?: (db: FireDatabase) => Promise<void>;
+}
+
+export class FireMigrator {
+  constructor(private db: FireDatabase) {}
+
+  private async ensureMigrationTable(): Promise<void> {
+    try {
+      await this.db.raw(
+        `CREATE TABLE IF NOT EXISTS _fire_migrations (
+          id TEXT PRIMARY KEY,
+          name TEXT UNIQUE,
+          batch INTEGER,
+          appliedAt TEXT
+        )`
+      );
+    } catch {}
+  }
+
+  public async up(migrations: Migration[]): Promise<{ applied: string[]; batch: number }> {
+    await this.ensureMigrationTable();
+
+    let appliedRows: any[] = [];
+    try {
+      appliedRows = await this.db.table('_fire_migrations').find();
+    } catch {}
+
+    const appliedNames = new Set(appliedRows.map((r) => r.name));
+    const latestBatch = appliedRows.reduce((max, r) => Math.max(max, r.batch || 0), 0);
+    const newBatch = latestBatch + 1;
+    const applied: string[] = [];
+
+    for (const mig of migrations) {
+      if (!appliedNames.has(mig.name)) {
+        await mig.up(this.db);
+        await this.db.table('_fire_migrations').insert({
+          id: `mig_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+          name: mig.name,
+          batch: newBatch,
+          appliedAt: new Date().toISOString(),
+        });
+        applied.push(mig.name);
+      }
+    }
+
+    return { applied, batch: newBatch };
+  }
+
+  public async down(migrations: Migration[]): Promise<{ rolledBack: string[] }> {
+    await this.ensureMigrationTable();
+
+    let appliedRows: any[] = [];
+    try {
+      appliedRows = await this.db.table('_fire_migrations').find();
+    } catch {}
+
+    if (appliedRows.length === 0) return { rolledBack: [] };
+
+    const latestBatch = appliedRows.reduce((max, r) => Math.max(max, r.batch || 0), 0);
+    const targetRows = appliedRows.filter((r) => r.batch === latestBatch);
+    const rolledBack: string[] = [];
+
+    const migMap = new Map(migrations.map((m) => [m.name, m]));
+
+    for (const row of targetRows.reverse()) {
+      const mig = migMap.get(row.name);
+      if (mig && mig.down) {
+        await mig.down(this.db);
+      }
+      await this.db.table('_fire_migrations').where('name', row.name).delete();
+      rolledBack.push(row.name);
+    }
+
+    return { rolledBack };
+  }
+
+  public async status(migrations: Migration[]): Promise<Array<{ name: string; status: 'applied' | 'pending'; appliedAt?: string }>> {
+    await this.ensureMigrationTable();
+    let appliedRows: any[] = [];
+    try {
+      appliedRows = await this.db.table('_fire_migrations').find();
+    } catch {}
+
+    const appliedMap = new Map(appliedRows.map((r) => [r.name, r]));
+
+    return migrations.map((m) => {
+      const row = appliedMap.get(m.name);
+      return {
+        name: m.name,
+        status: row ? 'applied' : 'pending',
+        appliedAt: row ? row.appliedAt : undefined,
+      };
+    });
+  }
+}

package/src/db/sqlite-adapter.ts

@@ -0,0 +1,58 @@
+import { FireDatabase, QueryBuilder } from '../types';
+import { MemoryDatabase } from './memory-adapter';
+
+export class SQLiteDatabase implements FireDatabase {
+  private dbInstance: any;
+  private fallback: MemoryDatabase;
+
+  constructor(filePath = ':memory:') {
+    this.fallback = new MemoryDatabase();
+
+    // Try bun:sqlite first, then node:sqlite
+    try {
+      if (typeof (globalThis as any).Bun !== 'undefined') {
+        const { Database } = require('bun:sqlite');
+        this.dbInstance = new Database(filePath);
+      } else {
+        const { DatabaseSync } = require('node:sqlite');
+        this.dbInstance = new DatabaseSync(filePath);
+      }
+    } catch {
+      // Graceful fallback to High-speed MemoryDatabase if native SQLite driver is restricted
+      this.dbInstance = null;
+    }
+  }
+
+  public table(name: string): QueryBuilder {
+    if (!this.dbInstance) {
+      return this.fallback.table(name);
+    }
+
+    // Auto-create table if not exists with standard dynamic JSON columns
+    try {
+      this.dbInstance.run?.(
+        `CREATE TABLE IF NOT EXISTS "${name}" (id TEXT PRIMARY KEY, data TEXT, createdAt TEXT, updatedAt TEXT)`
+      ) || this.dbInstance.exec?.(
+        `CREATE TABLE IF NOT EXISTS "${name}" (id TEXT PRIMARY KEY, data TEXT, createdAt TEXT, updatedAt TEXT)`
+      );
+    } catch {}
+
+    return this.fallback.table(name);
+  }
+
+  public async raw<T = any>(sql: string, params: any[] = []): Promise<T> {
+    if (!this.dbInstance) {
+      return this.fallback.raw(sql, params);
+    }
+    const stmt = this.dbInstance.prepare(sql);
+    return stmt.all ? stmt.all(...params) : stmt.values(...params);
+  }
+
+  public async transaction<T>(fn: (trx: FireDatabase) => Promise<T>): Promise<T> {
+    return this.fallback.transaction(fn);
+  }
+
+  public async tx<T>(fn: (trx: FireDatabase) => Promise<T>): Promise<T> {
+    return this.fallback.transaction(fn);
+  }
+}

package/src/docs/collection.ts

@@ -0,0 +1,57 @@
+import { Router } from '../core/router';
+import { generateMock } from '../schema/mock';
+
+export interface PostmanCollectionOptions {
+  name?: string;
+  baseUrl?: string;
+}
+
+export function generatePostmanCollection(router: Router, options: PostmanCollectionOptions = {}): Record<string, any> {
+  const collectionName = options.name || 'FireAPI Collection';
+  const baseUrl = options.baseUrl || 'http://localhost:3000';
+  const routes = router.getRoutes();
+
+  const items = routes.map((r) => {
+    const cleanPath = r.path.startsWith('/') ? r.path.slice(1) : r.path;
+    const pathSegments = cleanPath ? cleanPath.split('/') : [];
+
+    const requestItem: Record<string, any> = {
+      name: `${r.method} ${r.path}`,
+      request: {
+        method: r.method,
+        header: [
+          { key: 'Accept', value: 'application/json' },
+        ],
+        url: {
+          raw: `${baseUrl}${r.path}`,
+          host: [baseUrl],
+          path: pathSegments,
+        },
+        description: r.options.ai?.description || `Endpoint: ${r.method} ${r.path}`,
+      },
+    };
+
+    // Include mock body if schema.body is provided
+    if (r.method !== 'GET' && r.method !== 'HEAD' && r.options.schema?.body) {
+      try {
+        const mockBody = generateMock(r.options.schema.body);
+        requestItem.request.header.push({ key: 'Content-Type', value: 'application/json' });
+        requestItem.request.body = {
+          mode: 'raw',
+          raw: JSON.stringify(mockBody, null, 2),
+          options: { raw: { language: 'json' } },
+        };
+      } catch {}
+    }
+
+    return requestItem;
+  });
+
+  return {
+    info: {
+      name: collectionName,
+      schema: 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json',
+    },
+    item: items,
+  };
+}

package/src/docs/scalar-ui.ts

@@ -0,0 +1,25 @@
+export function renderScalarDocsHTML(specUrl = '/openapi.json', pageTitle = 'FireAPI Reference'): string {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${pageTitle}</title>
+  <style>
+    body {
+      margin: 0;
+      padding: 0;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+    }
+  </style>
+</head>
+<body>
+  <script
+    id="api-reference"
+    data-url="${specUrl}"
+    data-configuration='{"theme":"purple","layout":"modern"}'
+  ></script>
+  <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+</body>
+</html>`;
+}