FROM node:24-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 4321
CMD ["npm", "start"]

B --> C[Service Layer]
C --> D[Database]
C --> E[Cache]
B --> F[Authentication]

-->

### Data Flow

<!--
```mermaid
sequenceDiagram
    participant Client
    participant API
    participant Service
    participant Database

    Client->>API: Request
    API->>Service: Process
    Service->>Database: Query
    Database->>Service: Results
    Service->>API: Response
    API->>Client: JSON

A --> C[UI Module]
A --> D[Data Module]
B --> E[Config]
B --> F[Logger]
C --> G[Components]
C --> H[Styles]
D --> I[Models]
D --> J[Services]

-->

## Configuration

### Environment Variables

| Variable | Description | Default | Required |
|----------|-------------|---------|----------|
| `PORT` | Server port | `4321` | No |
| `DATABASE_URL` | Database connection | - | Yes |
| `API_KEY` | External API key | - | Yes |
| `LOG_LEVEL` | Logging verbosity | `info` | No |

### Configuration File

```json
{
  "server": {
    "port": 4321,
    "host": "localhost"
  },
  "database": {
    "type": "postgresql",
    "host": "localhost",
    "port": 5432,
    "poolSize": 10
  },
  "features": {
    "authentication": true,
    "caching": true,
    "analytics": false
  }
}

POST /api/auth/login
Content-Type: application/json

{
  "username": "user@example.com",
  "password": "secure_password"
}

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "expiresIn": 3600,
  "user": {
    "id": "123",
    "email": "user@example.com"
  }
}

1
// Main application class
2
import { Config } from './config';
3
import { Logger } from './logger';
4

5
interface User {
6
  id: string;
7
  name: string;
8
  email: string;
9
  createdAt: Date;
10
}
11

12
class Application {
13
  private config: Config;
14
  private logger: Logger;
15

16
  constructor(config: Config) {
17
    this.config = config;
18
    this.logger = new Logger(config.logLevel);
19
  }
20

21
  async start(): Promise<void> {
22
    this.logger.info('Starting application...');
23

24
    try {
25
      await this.initializeDatabase();
26
      await this.startServer();
27
      this.logger.info('Application started successfully');
28
    } catch (error) {
29
      this.logger.error('Failed to start application', error);
30
      throw error;
31
    }
32
  }
33

34
  private async initializeDatabase(): Promise<void> {
35
    // Database initialization logic
36
  }
37

38
  private async startServer(): Promise<void> {
39
    // Server startup logic
40
  }
41
}
42

43
export { Application, User };

1
# Data processing module
2
from typing import List, Dict, Optional
3
import asyncio
4
import logging
5

6
class DataProcessor:
7
    """Handles data processing operations."""
8

9
    def __init__(self, config: Dict[str, any]):
10
        self.config = config
11
        self.logger = logging.getLogger(__name__)
12

13
    async def process_batch(
14
        self,
15
        items: List[Dict],
16
        batch_size: int = 100
17
    ) -> List[Dict]:
18
        """Process items in batches."""
19
        results = []
20

21
        for i in range(0, len(items), batch_size):
22
            batch = items[i:i + batch_size]
23
            processed = await self._process_items(batch)
24
            results.extend(processed)
25

26
        return results
27

28
    async def _process_items(
29
        self,
30
        items: List[Dict]
31
    ) -> List[Dict]:
32
        """Process individual items."""
33
        tasks = [self._process_item(item) for item in items]
34
        return await asyncio.gather(*tasks)
35

36
    async def _process_item(self, item: Dict) -> Dict:
37
        """Process a single item."""
38
        # Processing logic here
39
        return {
40
            **item,
41
            'processed': True,
42
            'timestamp': datetime.now()
43
        }

1
// Core service implementation
2
use std::sync::Arc;
3
use tokio::sync::RwLock;
4
use serde::{Serialize, Deserialize};
5

6
#[derive(Debug, Clone, Serialize, Deserialize)]
7
pub struct Item {
8
    pub id: String,
9
    pub name: String,
10
    pub value: i32,
11
}
12

13
pub struct Service {
14
    items: Arc<RwLock<Vec<Item>>>,
15
}
16

17
impl Service {
18
    pub fn new() -> Self {
19
        Self {
20
            items: Arc::new(RwLock::new(Vec::new())),
21
        }
22
    }
23

24
    pub async fn add_item(&self, item: Item) -> Result<(), String> {
25
        let mut items = self.items.write().await;
26
        items.push(item);
27
        Ok(())
28
    }
29

30
    pub async fn get_items(&self) -> Vec<Item> {
31
        let items = self.items.read().await;
32
        items.clone()
33
    }
34

35
    pub async fn find_by_id(&self, id: &str) -> Option<Item> {
36
        let items = self.items.read().await;
37
        items.iter().find(|item| item.id == id).cloned()
38
    }
39
}

-- Database schema

-- Users table
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) UNIQUE NOT NULL,
    name VARCHAR(100) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- Items table
CREATE TABLE items (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id) ON DELETE CASCADE,
    title VARCHAR(200) NOT NULL,
    description TEXT,
    status VARCHAR(20) DEFAULT 'active',
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- Indexes
CREATE INDEX idx_items_user_id ON items(user_id);
CREATE INDEX idx_items_status ON items(status);
CREATE INDEX idx_users_email ON users(email);

-- Sample queries
SELECT u.name, COUNT(i.id) as item_count
FROM users u
LEFT JOIN items i ON u.id = i.user_id
WHERE i.status = 'active'
GROUP BY u.id, u.name
HAVING COUNT(i.id) > 0
ORDER BY item_count DESC
LIMIT 10;

version: '3.8'

services:
  app:
    build: .
    ports:
      - "4321:4321"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=${DATABASE_URL}
    depends_on:
      - database
      - redis

  database:
    image: postgres:16
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

MIT License

Copyright (c) 2025 Test Project

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.