Enterprise Application Example

1// src/server.ts - Enterprise Application with Functional Modules
2import { createApp } from '@morojs/moro';
3import UsersModule from './modules/users';
4import OrdersModule from './modules/orders';
5import TodosModule from './modules/todos';
6import HealthModule from './modules/health';
7
8async function createEnterpriseApp() {
9  // Use the functional createApp approach
10  const app = createApp({
11    cors: true,
12    compression: true,
13    helmet: true
14  });
15
16  // Simulated database (in real app, use MySQLAdapter)
17  const mockDatabase = {
18    users: [
19      { id: 1, name: 'John Doe', email: 'john@example.com', role: 'admin' },
20      { id: 2, name: 'Jane Smith', email: 'jane@example.com', role: 'user' }
21    ],
22    orders: [
23      { id: 1, userId: 1, product: 'Laptop', amount: 999.99, status: 'completed' },
24      { id: 2, userId: 2, product: 'Mouse', amount: 29.99, status: 'pending' }
25    ],
26    todos: [
27      { id: 1, title: 'Learn MoroJS', description: 'Explore the functional module architecture', completed: false, priority: 'high' }
28    ]
29  };
30
31  // Register database
32  app.database(mockDatabase);
33
34  // Add enterprise middleware
35  app.use((req: any, res: any, next: () => void) => {
36    console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
37    next();
38  });
39
40  // Load enterprise modules using the functional module system
41  await app.loadModule(HealthModule);
42  await app.loadModule(UsersModule);
43  await app.loadModule(OrdersModule);
44  await app.loadModule(TodosModule);
45
46  // Root endpoint
47  app.get('/', (req, res) => {
48    return {
49      message: 'Enterprise API with Functional Modules',
50      timestamp: new Date().toISOString(),
51      modules: ['health', 'users', 'orders', 'todos'],
52      architecture: 'functional-event-driven'
53    };
54  });
55
56  // Health check endpoint
57  app.get('/health', (req, res) => {
58    return {
59      status: 'ok',
60      timestamp: new Date().toISOString(),
61      uptime: process.uptime(),
62      architecture: 'Functional Modules Active'
63    };
64  });
65
66  return app;
67}
68
69async function bootstrap() {
70  try {
71    const app = await createEnterpriseApp();
72    const port = parseInt(process.env.PORT || '3002');
73
74    app.listen(port, () => {
75      console.log('🏢 Enterprise Application Started');
76      console.log(`HTTP API: http://localhost:${port}`);
77      console.log(`WebSocket: ws://localhost:${port}`);
78      console.log('Available APIs:');
79      console.log(`  Root: http://localhost:${port}/`);
80      console.log(`  Health: http://localhost:${port}/health`);
81      console.log(`  Users:  http://localhost:${port}/api/v1.0.0/users/`);
82      console.log(`  Orders: http://localhost:${port}/api/v1.0.0/orders/`);
83      console.log(`  Todos:  http://localhost:${port}/api/v1.0.0/todos/`);
84    });
85
86    // Graceful shutdown
87    process.on('SIGTERM', () => {
88      console.log('🏢 Enterprise app shutting down gracefully...');
89      process.exit(0);
90    });
91
92  } catch (error) {
93    console.error('❌ Failed to start enterprise application:', error);
94    process.exit(1);
95  }
96}
97
98bootstrap();

1enterprise-app/
2├── src/
3│   ├── modules/
4│   │   ├── users/
5│   │   │   ├── index.ts        # Module definition
6│   │   │   ├── routes.ts       # Route handlers
7│   │   │   ├── sockets.ts      # WebSocket handlers
8│   │   │   ├── actions.ts      # Business logic
9│   │   │   └── types.ts        # Type definitions
10│   │   ├── orders/
11│   │   │   ├── index.ts
12│   │   │   ├── routes.ts
13│   │   │   ├── actions.ts
14│   │   │   └── types.ts
15│   │   ├── todos/
16│   │   │   ├── index.ts
17│   │   │   ├── routes.ts
18│   │   │   ├── actions.ts
19│   │   │   └── types.ts
20│   │   └── health/
21│   │       └── index.ts
22│   └── server.ts               # Main application
23├── package.json
24├── tsconfig.json
25└── README.md
26
27// Key Features Demonstrated:
28✅ Functional modular architecture
29✅ Event-driven communication
30✅ In-memory data storage (easily replaceable)
31✅ Comprehensive validation with Zod
32✅ WebSocket support per module
33✅ Versioned API endpoints (/api/v1.0.0/)
34✅ Middleware system
35✅ Type-safe request handling
36✅ Clean separation of concerns
37✅ Easy module loading/unloading
38✅ Graceful shutdown handling
39✅ Development-friendly logging