dolphin-server-modules 1.0.0

package/controller/controller.ts

@@ -0,0 +1,248 @@
+// packages/core/controller.ts
+
+export interface DolphinController<T = any> {
+  list(req: any, userId?: string): Promise<any>;
+  get(req: any, userId?: string): Promise<T | null>;
+  create(req: any, userId?: string): Promise<T>;
+  update(req: any, userId?: string): Promise<T | null>;
+  delete(req: any, userId?: string): Promise<T | null>;
+  restore?(req: any, userId?: string): Promise<T | null>;
+  bulkUpdate?(req: any, userId?: string): Promise<number>;
+  bulkDelete?(req: any, userId?: string): Promise<number>;
+}
+
+export const createDolphinController = (
+  crud: any,
+  collection: string,
+  options?: {
+    softDelete?: boolean;
+    bulkOps?: boolean;
+  }
+): DolphinController => {
+  
+  const controller: DolphinController = {
+    
+    async list(req: any, userId?: string) {
+      const { page, limit, ...filter } = req.query || {};
+      
+      if (page !== undefined || limit !== undefined) {
+        return await crud.paginate(
+          collection,
+          filter,
+          Number(page) || 1,
+          Number(limit) || 100,
+          userId
+        );
+      }
+      
+      return await crud.read(collection, filter, {}, userId);
+    },
+    
+    async get(req: any, userId?: string) {
+      const id = req.params?.id || req.query?.id;
+      return await crud.readOne(collection, id, userId);
+    },
+    
+    async create(req: any, userId?: string) {
+      const data = req.body || {};
+      return await crud.create(collection, data, userId);
+    },
+    
+    async update(req: any, userId?: string) {
+      const id = req.params?.id || req.query?.id;
+      const data = req.body || {};
+      return await crud.updateOne(collection, id, data, userId);
+    },
+    
+    async delete(req: any, userId?: string) {
+      const id = req.params?.id || req.query?.id;
+      return await crud.deleteOne(collection, id, userId);
+    },
+  };
+  
+  if (options?.softDelete) {
+    controller.restore = async (req: any, userId?: string) => {
+      const id = req.params?.id || req.query?.id;
+      return await crud.restore(collection, id, userId);
+    };
+  }
+  
+  if (options?.bulkOps) {
+    controller.bulkUpdate = async (req: any, userId?: string) => {
+      const { filter, data } = req.body || {};
+      return await crud.updateMany(collection, filter, data, userId);
+    };
+    
+    controller.bulkDelete = async (req: any, userId?: string) => {
+      const { filter } = req.body || {};
+      return await crud.deleteMany(collection, filter, userId);
+    };
+  }
+  
+  return controller;
+};
+
+// ===== PAGES ROUTER HANDLER (req, res) =====
+export const createNextPagesHandler = (
+  controller: DolphinController,
+  options?: { requireAuth?: boolean; require2FA?: boolean }
+) => {
+  return async (req: any, res: any) => {
+    try {
+      const { method } = req;
+      let result;
+      
+      const userId = req.user?.id;
+      
+      switch (method) {
+        case 'GET':
+          if (req.query?.id) {
+            result = await controller.get(req, userId);
+          } else {
+            result = await controller.list(req, userId);
+          }
+          break;
+          
+        case 'POST':
+          result = await controller.create(req, userId);
+          break;
+          
+        case 'PUT':
+        case 'PATCH':
+          result = await controller.update(req, userId);
+          break;
+          
+        case 'DELETE':
+          result = await controller.delete(req, userId);
+          break;
+          
+        default:
+          return res.status(405).json({ error: 'Method not allowed' });
+      }
+      
+      return res.status(200).json(result);
+      
+    } catch (error: any) {
+      const status = error.status || 500;
+      return res.status(status).json({ error: error.message });
+    }
+  };
+};
+
+// ===== APP ROUTER HANDLER (Request, Response) =====
+export const createNextAppRoute = (controller: DolphinController) => {
+  
+  const handler = async (req: Request, context: { params: any }) => {
+    try {
+      const url = new URL(req.url);
+      const method = req.method;
+      
+      // Query params parse
+      const query = Object.fromEntries(url.searchParams.entries());
+      
+      // JSON body handle — safe parsing
+      let body = {};
+      if (['POST', 'PUT', 'PATCH'].includes(method)) {
+        try {
+          body = await req.json();
+        } catch {
+          body = {};
+        }
+      }
+      
+      // Mock request object for controller
+      const mockReq = {
+        query,
+        params: context.params || {},
+        body,
+        headers: Object.fromEntries(req.headers.entries()),
+      };
+      
+      // User from header (auth middleware le set gareko)
+      const userId = req.headers.get('x-user-id') || undefined;
+      
+      let result;
+      
+      switch (method) {
+        case 'GET':
+          if (context.params?.id || query.id) {
+            result = await controller.get(mockReq, userId);
+          } else {
+            result = await controller.list(mockReq, userId);
+          }
+          break;
+          
+        case 'POST':
+          result = await controller.create(mockReq, userId);
+          break;
+          
+        case 'PUT':
+        case 'PATCH':
+          result = await controller.update(mockReq, userId);
+          break;
+          
+        case 'DELETE':
+          result = await controller.delete(mockReq, userId);
+          break;
+          
+        default:
+          return new Response(
+            JSON.stringify({ error: 'Method not allowed' }),
+            { status: 405, headers: { 'Content-Type': 'application/json' } }
+          );
+      }
+      
+      return new Response(
+        JSON.stringify(result),
+        { status: 200, headers: { 'Content-Type': 'application/json' } }
+      );
+      
+    } catch (error: any) {
+      const status = error.status || 500;
+      return new Response(
+        JSON.stringify({ error: error.message }),
+        { status, headers: { 'Content-Type': 'application/json' } }
+      );
+    }
+  };
+  
+  // Return route handlers for App Router
+  return {
+    GET: handler,
+    POST: handler,
+    PUT: handler,
+    PATCH: handler,
+    DELETE: handler,
+  };
+};
+
+// ===== DYNAMIC ROUTE HANDLER (for [id].ts) =====
+export const createNextDynamicHandler = (controller: DolphinController) => {
+  return async (req: any, res: any) => {
+    try {
+      const { method } = req;
+      const userId = req.user?.id;
+      let result;
+      
+      switch (method) {
+        case 'GET':
+          result = await controller.get(req, userId);
+          break;
+        case 'PUT':
+        case 'PATCH':
+          result = await controller.update(req, userId);
+          break;
+        case 'DELETE':
+          result = await controller.delete(req, userId);
+          break;
+        default:
+          return res.status(405).json({ error: 'Method not allowed' });
+      }
+      
+      return res.status(200).json(result);
+      
+    } catch (error: any) {
+      return res.status(error.status || 500).json({ error: error.message });
+    }
+  };
+};

package/curd/crud.ts

@@ -0,0 +1,267 @@
+// crud-lite.ts — World-class lightweight CRUD (2026 style, full-featured)
+// Compatible with your auth DatabaseAdapter
+
+import crypto from 'node:crypto';
+
+// ===== DATABASE ADAPTER INTERFACE =====
+export interface DatabaseAdapter {
+  createUser(data: any): Promise<any>;
+  findUserByEmail(email: string): Promise<any>;
+  findUserById(id: string): Promise<any>;
+  updateUser(id: string, data: any): Promise<any>;
+  saveRefreshToken(data: any): Promise<void>;
+  findRefreshToken(token: string): Promise<any>;
+  deleteRefreshToken(token: string): Promise<void>;
+  create(collection: string, data: any): Promise<any>;
+  read(collection: string, query: any): Promise<any[]>;
+  update(collection: string, query: any, data: any): Promise<any>;
+  delete(collection: string, query: any): Promise<any>;
+  advancedRead?(collection: string, query: any, options: any): Promise<any[]>;
+}
+
+// ===== DOCUMENT BASE TYPE =====
+export interface BaseDocument {
+  id: string;
+  userId?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  deletedAt?: string | null;
+  [key: string]: any; // Index signature for dynamic fields
+}
+
+// ===== Query Filter Type =====
+export type QueryFilter<T extends BaseDocument = BaseDocument> = {
+  [K in keyof T]?: T[K] | { $eq?: T[K]; $ne?: T[K]; $gt?: T[K]; $gte?: T[K]; $lt?: T[K]; $lte?: T[K]; $in?: T[K][]; $nin?: T[K][]; $like?: string };
+} & {
+  $and?: QueryFilter<T>[];
+  $or?: QueryFilter<T>[];
+};
+
+// ===== Pagination =====
+export interface PaginationOptions {
+  limit?: number;
+  offset?: number;
+  sort?: { [key: string]: 'asc' | 'desc' };
+}
+
+// ===== CRUD Factory =====
+export function createCRUD<T extends BaseDocument = BaseDocument>(
+  db: DatabaseAdapter,
+  options: { enforceOwnership?: boolean; softDelete?: boolean; defaultLimit?: number } = {}
+) {
+  const { enforceOwnership = true, softDelete = false, defaultLimit = 100 } = options;
+
+  const generateId = () => crypto.randomBytes(12).toString('hex');
+
+  const applyOwnership = <U extends BaseDocument>(query: QueryFilter<U>, userId?: string): QueryFilter<U> => {
+    if (!enforceOwnership || !userId) return query;
+    return { ...query, userId: { $eq: userId } };
+  };
+
+  const matchFilter = <U extends BaseDocument>(item: any, filter: QueryFilter<U>): boolean => {
+    const ops = (field: string, val: any, cond: any): boolean => {
+      if (cond === undefined) return val !== undefined;
+      if (typeof cond !== 'object') return val === cond;
+      if ('$eq' in cond) return val === cond.$eq;
+      if ('$ne' in cond) return val !== cond.$ne;
+      if ('$gt' in cond) return val > cond.$gt;
+      if ('$gte' in cond) return val >= cond.$gte;
+      if ('$lt' in cond) return val < cond.$lt;
+      if ('$lte' in cond) return val <= cond.$lte;
+      if ('$in' in cond) return Array.isArray(cond.$in) && cond.$in.includes(val);
+      if ('$nin' in cond) return Array.isArray(cond.$nin) && !cond.$nin.includes(val);
+      if ('$like' in cond) return typeof val === 'string' && val.includes(String(cond.$like));
+      return true;
+    };
+
+    const keys = Object.keys(filter);
+    for (const key of keys) {
+      const fval: any = (filter as any)[key];
+      if (key === '$and') {
+        if (!Array.isArray(fval) || !fval.every((f: any) => matchFilter(item, f))) return false;
+      } else if (key === '$or') {
+        if (!Array.isArray(fval) || !fval.some((f: any) => matchFilter(item, f))) return false;
+      } else {
+        if (!ops(key, (item as any)[key], fval)) return false;
+      }
+    }
+    return true;
+  };
+
+  const applySoftDelete = (items: T[]): T[] => {
+    if (!softDelete) return items;
+    return items.filter(i => !i.deletedAt);
+  };
+
+  const applySort = (items: T[], sort?: { [key: string]: 'asc' | 'desc' }) => {
+    if (!sort) return items;
+    const keys = Object.keys(sort);
+    return [...items].sort((a, b) => {
+      for (const k of keys) {
+        const aVal = (a as any)[k];
+        const bVal = (b as any)[k];
+        if (aVal === bVal) continue;
+        return sort[k] === 'asc' ? (aVal > bVal ? 1 : -1) : (aVal > bVal ? -1 : 1);
+      }
+      return 0;
+    });
+  };
+
+  return {
+    async create(collection: string, data: Partial<T>, userId?: string): Promise<T> {
+      const now = new Date().toISOString();
+      const doc = {
+        id: generateId(),
+        createdAt: now,
+        updatedAt: now,
+        ...(userId && { userId }),
+        ...data
+      } as T;
+      return db.create(collection, doc);
+    },
+
+    async createMany(collection: string, items: Array<Partial<T>>, userId?: string): Promise<T[]> {
+      const now = new Date().toISOString();
+      const docs = items.map(item => ({
+        id: generateId(),
+        createdAt: now,
+        updatedAt: now,
+        ...(userId && { userId }),
+        ...item
+      })) as T[];
+      
+      const results: T[] = [];
+      for (const doc of docs) {
+        results.push(await db.create(collection, doc));
+      }
+      return results;
+    },
+
+    async readOne(collection: string, id: string, userId?: string): Promise<T | null> {
+      const filter = applyOwnership({ id }, userId);
+      const results = await db.read(collection, filter);
+      const filtered = applySoftDelete(results);
+      return filtered[0] || null;
+    },
+
+    async read(
+      collection: string,
+      filter: QueryFilter<T> = {},
+      options: PaginationOptions = {},
+      userId?: string
+    ): Promise<T[]> {
+      const safeFilter = applyOwnership(filter, userId);
+      let items: T[] = [];
+
+      if (db.advancedRead) {
+        items = await db.advancedRead(collection, safeFilter, options);
+      } else {
+        const raw = await db.read(collection, {});
+        items = applySoftDelete(raw).filter(i => matchFilter(i, safeFilter));
+      }
+
+      if (options.sort) items = applySort(items, options.sort);
+      if (options.offset || options.limit !== undefined) {
+        const start = options.offset || 0;
+        const end = start + (options.limit ?? items.length);
+        items = items.slice(start, end);
+      }
+
+      return items;
+    },
+
+    async updateOne(collection: string, id: string, data: Partial<T>, userId?: string): Promise<T | null> {
+      const filter = applyOwnership({ id }, userId);
+      const results = await db.read(collection, filter);
+      if (results.length === 0) return null;
+      
+      const updateData = { ...data, updatedAt: new Date().toISOString() };
+      await db.update(collection, filter, updateData);
+      return { ...results[0], ...updateData } as T;
+    },
+
+    async updateMany(collection: string, filter: QueryFilter<T>, data: Partial<T>, userId?: string): Promise<number> {
+      const safeFilter = applyOwnership(filter, userId);
+      const items = await this.read(collection, safeFilter, {}, userId);
+      const updateData = { ...data, updatedAt: new Date().toISOString() };
+      
+      for (const item of items) {
+        await db.update(collection, { id: item.id }, updateData);
+      }
+      return items.length;
+    },
+
+    async deleteOne(collection: string, id: string, userId?: string): Promise<T | null> {
+      const filter = applyOwnership({ id }, userId);
+      const results = await db.read(collection, filter);
+      if (results.length === 0) return null;
+
+      if (softDelete) {
+        await db.update(collection, filter, { deletedAt: new Date().toISOString() });
+        return results[0] as T;
+      } else {
+        await db.delete(collection, filter);
+        return results[0] as T;
+      }
+    },
+
+    async deleteMany(collection: string, filter: QueryFilter<T>, userId?: string): Promise<number> {
+      const safeFilter = applyOwnership(filter, userId);
+      const items = await this.read(collection, safeFilter, {}, userId);
+      
+      if (softDelete) {
+        for (const item of items) {
+          await db.update(collection, { id: item.id }, { deletedAt: new Date().toISOString() });
+        }
+      } else {
+        await db.delete(collection, safeFilter);
+      }
+      return items.length;
+    },
+
+    async restore(collection: string, id: string, userId?: string): Promise<T | null> {
+      if (!softDelete) throw new Error('Soft delete not enabled');
+      const filter = applyOwnership({ id, deletedAt: { $ne: null } }, userId);
+      const results = await db.read(collection, filter);
+      if (results.length === 0) return null;
+      
+      // ✅ FIX: Set deletedAt to null to explicitly restore
+      const updateData = { ...results[0], deletedAt: null, updatedAt: new Date().toISOString() };
+      await db.update(collection, filter, updateData);
+      return this.readOne(collection, id, userId);
+    },
+
+    async count(collection: string, filter: QueryFilter<T> = {}, userId?: string): Promise<number> {
+      const safeFilter = applyOwnership(filter, userId);
+      const raw = await db.read(collection, {});
+      return applySoftDelete(raw).filter(i => matchFilter(i, safeFilter)).length;
+    },
+
+    async exists(collection: string, filter: QueryFilter<T>, userId?: string): Promise<boolean> {
+      const count = await this.count(collection, filter, userId);
+      return count > 0;
+    },
+
+    async paginate(
+      collection: string, 
+      filter: QueryFilter<T> = {}, 
+      page: number = 1, 
+      limit: number = defaultLimit, 
+      userId?: string
+    ) {
+      const offset = (page - 1) * limit;
+      const items = await this.read(collection, filter, { limit, offset }, userId);
+      const total = await this.count(collection, filter, userId);
+      
+      return {
+        items,
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+        hasNext: page * limit < total,
+        hasPrev: page > 1
+      };
+    }
+  };
+}

package/dist/auth/auth.d.ts

@@ -0,0 +1,81 @@
+export interface RefreshTokenRecord {
+    token: string;
+    userId: string;
+    expiresAt: Date;
+    twoFactorVerified: boolean;
+}
+export interface DatabaseAdapter {
+    createUser(data: any): Promise<any>;
+    findUserByEmail(email: string): Promise<any>;
+    findUserById(id: string): Promise<any>;
+    updateUser(id: string, data: any): Promise<any>;
+    saveRefreshToken(data: RefreshTokenRecord): Promise<void>;
+    findRefreshToken(token: string): Promise<RefreshTokenRecord | null>;
+    deleteRefreshToken(token: string): Promise<void>;
+}
+export declare function createAuth(config: {
+    secret: string;
+    redisClient?: any;
+    cookieMaxAge?: number;
+    issuer?: string;
+    rateLimit?: {
+        max: number;
+        window: number;
+    };
+}): {
+    register(db: DatabaseAdapter, data: {
+        email: string;
+        password: string;
+    }): Promise<{
+        id: any;
+        email: any;
+        role: any;
+    }>;
+    login(db: DatabaseAdapter, input: {
+        email: string;
+        password: string;
+        totp?: string;
+        recovery?: string;
+    }, res?: {
+        cookie: (name: string, value: string, options: any) => void;
+    }): Promise<{
+        accessToken: string;
+        user: {
+            id: any;
+            email: any;
+            role: any;
+            twoFactorEnabled: any;
+        };
+    }>;
+    enable2FA(db: DatabaseAdapter, userId: string): Promise<{
+        secret: string;
+        uri: string;
+    }>;
+    verify2FA(db: DatabaseAdapter, userId: string, totp: string): Promise<{
+        recoveryCodes: string[];
+    }>;
+    refresh(db: DatabaseAdapter, refreshToken: string, res?: {
+        cookie: (name: string, value: string, options: any) => void;
+    }): Promise<{
+        accessToken: string;
+        user: {
+            id: any;
+            email: any;
+            role: any;
+            twoFactorEnabled: any;
+        };
+    }>;
+    logout(db: DatabaseAdapter, refreshToken: string): Promise<{
+        success: boolean;
+    }>;
+    disable2FA(db: DatabaseAdapter, userId: string, totp: string): Promise<{
+        success: boolean;
+    }>;
+    regenerateRecoveryCodes(db: DatabaseAdapter, userId: string, totp: string): Promise<{
+        recoveryCodes: string[];
+    }>;
+    middleware(opts?: {
+        require2FA?: boolean;
+    }): (req: any, res: any, next: Function) => Promise<any>;
+    verifyToken: (token: string) => Promise<any>;
+};