@fjell/express-router 4.4.22 → 4.4.24

package/examples/full-application-example.ts

@@ -12,7 +12,7 @@
  */
 
 import express, { Application, NextFunction, Request, Response } from 'express';
-import { ComKey, Item, PriKey, UUID } from '@fjell/core';
+import { ComKey, Item, LocKey, PriKey, UUID } from '@fjell/core';
 import { CItemRouter, createRegistry, PItemRouter } from '../src';
 
 // ===== Data Models =====
@@ -280,12 +280,23 @@ const createCustomerOperations = () => ({
   async update(key: PriKey<'customer'>, updates: Partial<Customer>) {
     const existing = mockCustomerStorage.get(String(key.pk));
     if (!existing) throw new Error(`Customer not found: ${key.pk}`);
-    const updated = { ...existing, ...updates };
+    const updated = {
+      ...existing,
+      ...updates,
+      key: existing.key, // Preserve the key
+      events: {
+        ...existing.events,
+        updated: { at: new Date() }
+      }
+    };
     mockCustomerStorage.set(String(key.pk), updated);
     return updated;
   },
   async remove(key: PriKey<'customer'>) {
-    return mockCustomerStorage.delete(String(key.pk));
+    const customer = mockCustomerStorage.get(String(key.pk));
+    if (!customer) throw new Error(`Customer not found: ${key.pk}`);
+    mockCustomerStorage.delete(String(key.pk));
+    return customer;
   },
   async find(finder: string, params: any) {
     const customers = Array.from(mockCustomerStorage.values());
@@ -318,12 +329,23 @@ const createProductOperations = () => ({
   async update(key: PriKey<'product'>, updates: Partial<Product>) {
     const existing = mockProductStorage.get(String(key.pk));
     if (!existing) throw new Error(`Product not found: ${key.pk}`);
-    const updated = { ...existing, ...updates };
+    const updated = {
+      ...existing,
+      ...updates,
+      key: existing.key, // Preserve the key
+      events: {
+        ...existing.events,
+        updated: { at: new Date() }
+      }
+    };
     mockProductStorage.set(String(key.pk), updated);
     return updated;
   },
   async remove(key: PriKey<'product'>) {
-    return mockProductStorage.delete(String(key.pk));
+    const product = mockProductStorage.get(String(key.pk));
+    if (!product) throw new Error(`Product not found: ${key.pk}`);
+    mockProductStorage.delete(String(key.pk));
+    return product;
   },
   async find(finder: string, params: any) {
     const products = Array.from(mockProductStorage.values());
@@ -344,25 +366,54 @@ const createOrderOperations = () => ({
     if (!order) throw new Error(`Order not found: ${key.pk}`);
     return order;
   },
-  async create(item: Order) {
+  async create(item: Order, options?: { locations?: any[] }) {
+    console.log('Order create called with:', { item, options });
     const id = `order-${Date.now()}`;
+    // Extract customerId from locations (passed from URL params) or item data
+    const customerId = options?.locations?.[0]?.lk || item.customerId;
+    console.log('Extracted customerId:', customerId);
+    if (!customerId) {
+      throw new Error('CustomerId is required for order creation');
+    }
     const newOrder: Order = {
       ...item,
       id,
-      key: { kt: 'order', pk: id as UUID, loc: (item.key as any)?.loc || [] },
+      customerId,
+      orderDate: item.orderDate ? new Date(item.orderDate) : new Date(),
+      key: {
+        kt: 'order',
+        pk: id as UUID,
+        loc: [{ kt: 'customer', lk: customerId }]
+      },
       events: { created: { at: new Date() }, updated: { at: new Date() }, deleted: { at: null } }
     };
+    console.log('Created order:', newOrder);
     mockOrderStorage.set(id, newOrder);
     return newOrder;
   },
   async update(key: ComKey<'order', 'customer'>, updates: Partial<Order>) {
     const existing = mockOrderStorage.get(String(key.pk));
     if (!existing) throw new Error(`Order not found: ${key.pk}`);
-    const updated = { ...existing, ...updates };
+    const updated = {
+      ...existing,
+      ...updates,
+      // Ensure orderDate is a Date object if it's being updated
+      ...(updates.orderDate && { orderDate: new Date(updates.orderDate) }),
+      key: existing.key, // Preserve the key
+      events: {
+        ...existing.events,
+        updated: { at: new Date() }
+      }
+    };
     mockOrderStorage.set(String(key.pk), updated);
     return updated;
   },
-  async remove(key: ComKey<'order', 'customer'>) { return mockOrderStorage.delete(String(key.pk)); },
+  async remove(key: ComKey<'order', 'customer'>) {
+    const order = mockOrderStorage.get(String(key.pk));
+    if (!order) throw new Error(`Order not found: ${key.pk}`);
+    mockOrderStorage.delete(String(key.pk));
+    return order;
+  },
   async find(finder: string, params: any) {
     const orders = Array.from(mockOrderStorage.values());
     switch (finder) {
@@ -376,6 +427,7 @@ const createOrderOperations = () => ({
 // ===== Middleware =====
 const errorHandler = (err: Error, req: Request, res: Response, next: NextFunction) => {
   console.error('❌ Application Error:', err.message);
+  console.error('❌ Stack trace:', err.stack);
   res.status(500).json({
     error: 'Internal Server Error',
     message: process.env.NODE_ENV === 'development' ? err.message : 'Something went wrong'
@@ -425,6 +477,36 @@ export const runFullApplicationExample = async (): Promise<{ app: Application }>
   app.use(requestLogger);
   app.use(validateCustomerTier);
 
+  // JSON parsing error handler
+  app.use((err: any, req: Request, res: Response, next: NextFunction) => {
+    if (err instanceof SyntaxError && 'body' in err) {
+      return res.status(400).json({ error: 'Invalid JSON' });
+    }
+    next(err);
+  });
+
+  // Validation middleware for customer creation only (not nested routes)
+  app.use('/api/customers', (req, res, next) => {
+    // Only validate for direct customer creation, not nested routes like orders
+    if (req.method === 'POST' && req.path === '/') {
+      const { name, email } = req.body;
+      if (!name || !email) {
+        return res.status(500).json({ error: 'Missing required fields: name and email' });
+      }
+    }
+    next();
+  });
+
+  app.use('/api/products', (req, res, next) => {
+    if (req.method === 'POST') {
+      const { name, price, category } = req.body;
+      if (!name || typeof price !== 'number' || !category) {
+        return res.status(500).json({ error: 'Missing required fields: name, price, and category' });
+      }
+    }
+    next();
+  });
+
   // ===== CORS and Security Headers =====
   app.use((req, res, next) => {
     res.header('Access-Control-Allow-Origin', '*');
@@ -461,10 +543,53 @@ export const runFullApplicationExample = async (): Promise<{ app: Application }>
   });
 
   // Core entity routes
-  app.use('/api/customers', customerRouter.getRouter());
   app.use('/api/products', productRouter.getRouter());
+
+  // Mount order router BEFORE customer router to avoid conflicts
+  // Middleware to extract customerPk parameter for order router
+  app.use('/api/customers/:customerPk/orders', (req, res, next) => {
+    res.locals.customerPk = req.params.customerPk;
+    next();
+  });
   app.use('/api/customers/:customerPk/orders', orderRouter.getRouter());
 
+  // Customer router last to avoid route conflicts
+  app.use('/api/customers', customerRouter.getRouter());
+
+  // Custom find routes for better test compatibility
+  app.get('/api/customers/find/:finder', async (req, res, next) => {
+    try {
+      const { finder } = req.params;
+      const params = req.query;
+      const customers = await customerInstance.operations.find(finder, params);
+      res.json(customers);
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.get('/api/products/find/:finder', async (req, res, next) => {
+    try {
+      const { finder } = req.params;
+      const params = req.query;
+      const products = await productInstance.operations.find(finder, params);
+      res.json(products);
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  app.get('/api/customers/:customerPk/orders/find/:finder', async (req, res, next) => {
+    try {
+      const { finder } = req.params;
+      const params = req.query;
+      const orders = await orderInstance.operations.find(finder, params);
+      res.json(orders);
+    } catch (error) {
+      next(error);
+    }
+  });
+
   // Business logic routes
   app.get('/api/dashboard', async (req, res, next) => {
     try {
@@ -489,7 +614,7 @@ export const runFullApplicationExample = async (): Promise<{ app: Application }>
         }, {}),
         featuredProducts: products.filter((product: Product) => product.featured),
         recentOrders: orders
-          .sort((a: Order, b: Order) => b.orderDate.getTime() - a.orderDate.getTime())
+          .sort((a: Order, b: Order) => new Date(b.orderDate).getTime() - new Date(a.orderDate).getTime())
           .slice(0, 10)
       };
 
@@ -561,7 +686,7 @@ export const runFullApplicationExample = async (): Promise<{ app: Application }>
           }, {})
         },
         recentOrders: customerOrders
-          .sort((a: Order, b: Order) => b.orderDate.getTime() - a.orderDate.getTime())
+          .sort((a: Order, b: Order) => new Date(b.orderDate).getTime() - new Date(a.orderDate).getTime())
           .slice(0, 5)
       };
 

package/examples/nested-router-example.ts

@@ -14,9 +14,10 @@
 import express, { Application } from 'express';
 import { ComKey, Item, PriKey, UUID } from '@fjell/core';
 import { CItemRouter, createRegistry, PItemRouter } from '../src';
+import { NotFoundError } from '@fjell/lib';
 
 // Define our hierarchical data models
-interface Organization extends Item<'organization'> {
+export interface Organization extends Item<'organization'> {
   id: string;
   name: string;
   type: 'startup' | 'enterprise' | 'nonprofit';
@@ -24,7 +25,7 @@ interface Organization extends Item<'organization'> {
   industry: string;
 }
 
-interface Department extends Item<'department', 'organization'> {
+export interface Department extends Item<'department', 'organization'> {
   id: string;
   name: string;
   budget: number;
@@ -32,7 +33,7 @@ interface Department extends Item<'department', 'organization'> {
   organizationId: string;
 }
 
-interface Employee extends Item<'employee', 'organization', 'department'> {
+export interface Employee extends Item<'employee', 'organization', 'department'> {
   id: string;
   name: string;
   email: string;
@@ -202,10 +203,15 @@ const createOrgOperations = () => ({
   },
   async get(key: PriKey<'organization'>) {
     const org = mockOrgStorage.get(String(key.pk));
-    if (!org) throw new Error(`Organization not found: ${key.pk}`);
+    if (!org) throw new NotFoundError('get', { kta: ['organization', '', '', '', '', ''], scopes: [] }, key);
     return org;
   },
   async create(item: Organization) {
+    // Validate required fields
+    if (!item.name || !item.type || !item.founded || !item.industry) {
+      throw new Error('Missing required fields: name, type, founded, and industry are required');
+    }
+
     const id = `org-${Date.now()}`;
     const newOrg: Organization = {
       ...item,
@@ -222,13 +228,23 @@ const createOrgOperations = () => ({
   },
   async update(key: PriKey<'organization'>, updates: Partial<Organization>) {
     const existing = mockOrgStorage.get(String(key.pk));
-    if (!existing) throw new Error(`Organization not found: ${key.pk}`);
-    const updated = { ...existing, ...updates };
+    if (!existing) throw new NotFoundError('update', { kta: ['organization', '', '', '', '', ''], scopes: [] }, key);
+    const updated = {
+      ...existing,
+      ...updates,
+      events: {
+        ...existing.events,
+        updated: { at: new Date() }
+      }
+    };
     mockOrgStorage.set(String(key.pk), updated);
     return updated;
   },
   async remove(key: PriKey<'organization'>) {
-    return mockOrgStorage.delete(String(key.pk));
+    const existing = mockOrgStorage.get(String(key.pk));
+    if (!existing) throw new NotFoundError('remove', { kta: ['organization', '', '', '', '', ''], scopes: [] }, key);
+    mockOrgStorage.delete(String(key.pk));
+    return existing;
   },
   async find(finder: string, params: any) {
     const orgs = Array.from(mockOrgStorage.values());
@@ -244,23 +260,35 @@ const createOrgOperations = () => ({
 });
 
 const createDeptOperations = () => ({
-  async all() {
-    return Array.from(mockDeptStorage.values());
+  async all(query?: any, locations?: any) {
+    const departments = Array.from(mockDeptStorage.values());
+    if (locations && locations.length >= 1) {
+      const orgId = String(locations[0]?.lk || '');
+      // Check if the parent organization exists
+      const org = mockOrgStorage.get(orgId);
+      if (!org) {
+        throw new NotFoundError('get', { kta: ['organization', '', '', '', '', ''], scopes: [] }, { kt: 'organization', pk: orgId as UUID });
+      }
+      return departments.filter(dept => dept.organizationId === orgId);
+    }
+    return departments;
   },
   async get(key: ComKey<'department', 'organization'>) {
     const dept = mockDeptStorage.get(String(key.pk));
-    if (!dept) throw new Error(`Department not found: ${key.pk}`);
+    if (!dept) throw new NotFoundError('get', { kta: ['department', '', '', '', '', ''], scopes: [] }, key);
     return dept;
   },
-  async create(item: Department) {
+  async create(item: Department, context?: any) {
     const id = `dept-${Date.now()}`;
+    const orgId = context?.locations?.[0]?.lk || item.organizationId || String((item.key as any)?.loc?.[0]?.lk || '');
     const newDept: Department = {
       ...item,
       id,
+      organizationId: orgId,
       key: {
         kt: 'department',
         pk: id as UUID,
-        loc: (item.key as any)?.loc || []
+        loc: context?.locations || (item.key as any)?.loc || []
       },
       events: {
         created: { at: new Date() },
@@ -273,45 +301,90 @@ const createDeptOperations = () => ({
   },
   async update(key: ComKey<'department', 'organization'>, updates: Partial<Department>) {
     const existing = mockDeptStorage.get(String(key.pk));
-    if (!existing) throw new Error(`Department not found: ${key.pk}`);
-    const updated = { ...existing, ...updates };
+    if (!existing) throw new NotFoundError('update', { kta: ['department', '', '', '', '', ''], scopes: [] }, key);
+    const updated = {
+      ...existing,
+      ...updates,
+      events: {
+        ...existing.events,
+        updated: { at: new Date() }
+      }
+    };
     mockDeptStorage.set(String(key.pk), updated);
     return updated;
   },
   async remove(key: ComKey<'department', 'organization'>) {
-    return mockDeptStorage.delete(String(key.pk));
+    const existing = mockDeptStorage.get(String(key.pk));
+    if (!existing) throw new NotFoundError('remove', { kta: ['department', '', '', '', '', ''], scopes: [] }, key);
+    mockDeptStorage.delete(String(key.pk));
+    return existing;
   },
-  async find(finder: string, params: any) {
-    const depts = Array.from(mockDeptStorage.values());
+  async find(finder: string, params: any, locations?: any) {
+    const departments = Array.from(mockDeptStorage.values());
+    let filtered = departments;
+
+    if (locations && locations.length >= 1) {
+      const orgId = String(locations[0]?.lk || '');
+      filtered = filtered.filter(dept => dept.organizationId === orgId);
+    }
+
     switch (finder) {
-      case 'byOrganization':
-        return depts.filter(dept => dept.organizationId === params.organizationId);
-      case 'byBudgetRange':
-        return depts.filter(dept => dept.budget >= params.min && dept.budget <= params.max);
+      case 'byBudget':
+        return filtered.filter(dept => dept.budget >= params.minBudget);
+      case 'byHeadCount':
+        return filtered.filter(dept => dept.headCount >= params.minHeadCount);
       default:
-        return depts;
+        return filtered;
     }
   }
 });
 
 const createEmpOperations = () => ({
-  async all() {
-    return Array.from(mockEmpStorage.values());
+  async all(query?: any, locations?: any) {
+    const employees = Array.from(mockEmpStorage.values());
+    if (locations && locations.length >= 2) {
+      // The locations array is: [{kt: 'department', lk: 'dept-1'}, {kt: 'organization', lk: 'org-1'}]
+      const deptId = String(locations[0]?.lk || '');
+      const orgId = String(locations[1]?.lk || '');
+
+      // Check if the parent organization exists
+      const org = mockOrgStorage.get(orgId);
+      if (!org) {
+        throw new NotFoundError('get', { kta: ['organization', '', '', '', '', ''], scopes: [] }, { kt: 'organization', pk: orgId as UUID });
+      }
+
+      // Check if the parent department exists
+      const dept = mockDeptStorage.get(deptId);
+      if (!dept) {
+        throw new NotFoundError('get', { kta: ['department', '', '', '', '', ''], scopes: [] }, { kt: 'department', pk: deptId as UUID });
+      }
+
+      return employees.filter(emp => emp.organizationId === orgId && emp.departmentId === deptId);
+    }
+    return employees;
   },
   async get(key: ComKey<'employee', 'organization', 'department'>) {
     const emp = mockEmpStorage.get(String(key.pk));
-    if (!emp) throw new Error(`Employee not found: ${key.pk}`);
+    if (!emp) throw new NotFoundError('get', { kta: ['employee', '', '', '', '', ''], scopes: [] }, key);
     return emp;
   },
-  async create(item: Employee) {
+  async create(item: Employee, context?: any) {
     const id = `emp-${Date.now()}`;
+
+    // Extract organization and department IDs from the locations context
+    // The locations array is: [{kt: 'department', lk: 'dept-1'}, {kt: 'organization', lk: 'org-1'}]
+    const deptId = context?.locations?.[0]?.lk || item.departmentId || String((item.key as any)?.loc?.[0]?.lk || '');
+    const orgId = context?.locations?.[1]?.lk || item.organizationId || String((item.key as any)?.loc?.[1]?.lk || '');
+
     const newEmp: Employee = {
       ...item,
       id,
+      organizationId: orgId,
+      departmentId: deptId,
       key: {
         kt: 'employee',
         pk: id as UUID,
-        loc: (item.key as any)?.loc || []
+        loc: context?.locations || (item.key as any)?.loc || []
       },
       events: {
         created: { at: new Date() },
@@ -324,23 +397,41 @@ const createEmpOperations = () => ({
   },
   async update(key: ComKey<'employee', 'organization', 'department'>, updates: Partial<Employee>) {
     const existing = mockEmpStorage.get(String(key.pk));
-    if (!existing) throw new Error(`Employee not found: ${key.pk}`);
-    const updated = { ...existing, ...updates };
+    if (!existing) throw new NotFoundError('update', { kta: ['employee', '', '', '', '', ''], scopes: [] }, key);
+    const updated = {
+      ...existing,
+      ...updates,
+      events: {
+        ...existing.events,
+        updated: { at: new Date() }
+      }
+    };
     mockEmpStorage.set(String(key.pk), updated);
     return updated;
   },
   async remove(key: ComKey<'employee', 'organization', 'department'>) {
-    return mockEmpStorage.delete(String(key.pk));
+    const existing = mockEmpStorage.get(String(key.pk));
+    if (!existing) throw new NotFoundError('remove', { kta: ['employee', '', '', '', '', ''], scopes: [] }, key);
+    mockEmpStorage.delete(String(key.pk));
+    return existing;
   },
-  async find(finder: string, params: any) {
+  async find(finder: string, params: any, locations?: any) {
     const employees = Array.from(mockEmpStorage.values());
+    let filtered = employees;
+
+    if (locations && locations.length >= 2) {
+      const deptId = String(locations[0]?.lk || '');
+      const orgId = String(locations[1]?.lk || '');
+      filtered = filtered.filter(emp => emp.organizationId === orgId && emp.departmentId === deptId);
+    }
+
     switch (finder) {
       case 'byDepartment':
-        return employees.filter(emp => emp.departmentId === params.departmentId);
+        return filtered.filter(emp => emp.departmentId === params.departmentId);
       case 'byPosition':
-        return employees.filter(emp => emp.position.includes(params.position));
+        return filtered.filter(emp => emp.position.includes(params.position));
       default:
-        return employees;
+        return filtered;
     }
   }
 });
@@ -389,26 +480,26 @@ export const runNestedRouterExample = async (): Promise<{ app: Application }> =>
   // Mount the routers to create nested endpoints:
   // Primary routes for organizations:
   // GET    /api/organizations                    - Get all organizations
-  // GET    /api/organizations/:orgPk            - Get specific organization
+  // GET    /api/organizations/:organizationPk    - Get specific organization
   // POST   /api/organizations                   - Create new organization
-  // PUT    /api/organizations/:orgPk            - Update organization
-  // DELETE /api/organizations/:orgPk            - Delete organization
+  // PUT    /api/organizations/:organizationPk    - Update organization
+  // DELETE /api/organizations/:organizationPk    - Delete organization
   app.use('/api/organizations', orgRouter.getRouter());
 
   // Nested routes for departments within organizations:
-  // GET    /api/organizations/:orgPk/departments           - Get all departments for organization
-  // GET    /api/organizations/:orgPk/departments/:deptPk   - Get specific department
-  // POST   /api/organizations/:orgPk/departments           - Create new department in organization
-  // PUT    /api/organizations/:orgPk/departments/:deptPk   - Update department
-  // DELETE /api/organizations/:orgPk/departments/:deptPk   - Delete department
+  // GET    /api/organizations/:organizationPk/departments           - Get all departments for organization
+  // GET    /api/organizations/:organizationPk/departments/:departmentPk   - Get specific department
+  // POST   /api/organizations/:organizationPk/departments           - Create new department in organization
+  // PUT    /api/organizations/:organizationPk/departments/:departmentPk   - Update department
+  // DELETE /api/organizations/:organizationPk/departments/:departmentPk   - Delete department
   app.use('/api/organizations/:organizationPk/departments', deptRouter.getRouter());
 
   // Deeply nested routes for employees within departments within organizations:
-  // GET    /api/organizations/:orgPk/departments/:deptPk/employees           - Get all employees for department
-  // GET    /api/organizations/:orgPk/departments/:deptPk/employees/:empPk    - Get specific employee
-  // POST   /api/organizations/:orgPk/departments/:deptPk/employees           - Create new employee in department
-  // PUT    /api/organizations/:orgPk/departments/:deptPk/employees/:empPk    - Update employee
-  // DELETE /api/organizations/:orgPk/departments/:deptPk/employees/:empPk    - Delete employee
+  // GET    /api/organizations/:organizationPk/departments/:departmentPk/employees           - Get all employees for department
+  // GET    /api/organizations/:organizationPk/departments/:departmentPk/employees/:employeePk    - Get specific employee
+  // POST   /api/organizations/:organizationPk/departments/:departmentPk/employees           - Create new employee in department
+  // PUT    /api/organizations/:organizationPk/departments/:departmentPk/employees/:employeePk    - Update employee
+  // DELETE /api/organizations/:organizationPk/departments/:departmentPk/employees/:employeePk    - Delete employee
   app.use('/api/organizations/:organizationPk/departments/:departmentPk/employees', empRouter.getRouter());
 
   // Additional hierarchy summary routes
@@ -470,16 +561,25 @@ export const runNestedRouterExample = async (): Promise<{ app: Application }> =>
   console.log('   📈 GET /api/stats                                                       - Statistics summary');
   console.log('   🏢 Organizations (Primary):');
   console.log('      GET    /api/organizations                                            - List all organizations');
-  console.log('      GET    /api/organizations/:orgPk                                     - Get specific organization');
+  console.log('      GET    /api/organizations/:organizationPk                            - Get specific organization');
   console.log('      POST   /api/organizations                                            - Create new organization');
   console.log('   🏬 Departments (Contained in Organizations):');
-  console.log('      GET    /api/organizations/:orgPk/departments                         - List departments for organization');
-  console.log('      GET    /api/organizations/:orgPk/departments/:deptPk                 - Get specific department');
-  console.log('      POST   /api/organizations/:orgPk/departments                         - Create department in organization');
+  console.log('      GET    /api/organizations/:organizationPk/departments                - List departments for organization');
+  console.log('      GET    /api/organizations/:organizationPk/departments/:departmentPk  - Get specific department');
+  console.log('      POST   /api/organizations/:organizationPk/departments                - Create department in organization');
   console.log('   👥 Employees (Contained in Departments):');
-  console.log('      GET    /api/organizations/:orgPk/departments/:deptPk/employees       - List employees for department');
-  console.log('      GET    /api/organizations/:orgPk/departments/:deptPk/employees/:empPk - Get specific employee');
-  console.log('      POST   /api/organizations/:orgPk/departments/:deptPk/employees       - Create employee in department');
+  console.log('      GET    /api/organizations/:organizationPk/departments/:departmentPk/employees       - List employees for department');
+  console.log('      GET    /api/organizations/:organizationPk/departments/:departmentPk/employees/:employeePk - Get specific employee');
+  console.log('      POST   /api/organizations/:organizationPk/departments/:departmentPk/employees       - Create employee in department');
+
+  // Error handling middleware
+  app.use((err: any, req: any, res: any, next: any) => {
+    console.error('Error:', err.message);
+    if (err instanceof NotFoundError || err.message.includes('not found') || err.message.includes('NotFoundError')) {
+      return res.status(404).json({ error: err.message });
+    }
+    res.status(500).json({ error: 'Internal server error' });
+  });
 
   return { app };
 };