@fjell/express-router 4.4.23 → 4.4.24

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 };
 };