// TypeScript - Named exports/imports
export function helperFunction() { /* ... */ }
export class User { /* ... */ }

import { helperFunction, User } from './utils';
import { readFile } from 'fs/promises';

// Default export/import
export default class Database { /* ... */ }
import Database from './database';

// Import everything
import * as fs from 'fs/promises';

// Giống Python async/await
async function fetchUser(id: number): Promise<User> {
    try {
        const response = await fetch(`/api/users/${id}`);
        if (!response.ok) {
            throw new Error(`HTTP ${response.status}`);
        }
        const userData = await response.json();
        return userData as User;
    } catch (error) {
        console.error('Fetch failed:', error);
        throw error;
    }
}

// Promise chaining (ít dùng)
function fetchUserOldWay(id: number): Promise<User> {
    return fetch(`/api/users/${id}`)
        .then(response => response.json())
        .then(data => data as User);
}

import { readFile, writeFile } from 'fs/promises';
import { existsSync } from 'fs';

// Đọc file
async function loadConfig(): Promise<Config> {
    try {
        const data = await readFile('config.json', 'utf8');
        return JSON.parse(data) as Config;
    } catch (error) {
        console.error('Cannot load config:', error);
        return getDefaultConfig();
    }
}

// Ghi file
async function saveData(data: any[], filename: string): Promise<void> {
    const jsonData = JSON.stringify(data, null, 2);
    await writeFile(filename, jsonData, 'utf8');
    console.log(`Saved ${data.length} records to ${filename}`);
}

// Kiểm tra file tồn tại
if (existsSync('data.csv')) {
    const csvContent = await readFile('data.csv', 'utf8');
    // Process CSV...
}

interface ApiResponse<T> {
    data: T;
    status: number;
    message?: string;
}

class ApiClient {
    private baseUrl: string;
    
    constructor(baseUrl: string) {
        this.baseUrl = baseUrl;
    }
    
    async get<T>(endpoint: string): Promise<T> {
        const response = await fetch(`${this.baseUrl}${endpoint}`, {
            method: 'GET',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${this.getToken()}`
            }
        });
        
        if (!response.ok) {
            throw new Error(`GET ${endpoint} failed: ${response.status}`);
        }
        
        return response.json() as T;
    }
    
    async post<T>(endpoint: string, data: any): Promise<T> {
        const response = await fetch(`${this.baseUrl}${endpoint}`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify(data)
        });
        
        return response.json() as T;
    }
    
    private getToken(): string {
        return process.env.API_TOKEN || '';
    }
}

// Sử dụng
const api = new ApiClient('https://api.example.com');
const users = await api.get<User[]>('/users');

import express, { Request, Response } from 'express';

interface User {
    id: number;
    name: string;
    email: string;
}

const app = express();
app.use(express.json());

let users: User[] = [
    { id: 1, name: 'Alice', email: 'alice@example.com' },
    { id: 2, name: 'Bob', email: 'bob@example.com' }
];

// GET /users
app.get('/users', (req: Request, res: Response) => {
    res.json(users);
});

// GET /users/:id
app.get('/users/:id', (req: Request, res: Response) => {
    const id = parseInt(req.params.id);
    const user = users.find(u => u.id === id);
    
    if (!user) {
        return res.status(404).json({ error: 'User not found' });
    }
    
    res.json(user);
});

// POST /users
app.post('/users', (req: Request, res: Response) => {
    const { name, email }: Partial<User> = req.body;
    
    if (!name || !email) {
        return res.status(400).json({ error: 'Name and email required' });
    }
    
    const newUser: User = {
        id: users.length + 1,
        name,
        email
    };
    
    users.push(newUser);
    res.status(201).json(newUser);
});

app.listen(3000, () => {
    console.log('Server running on http://localhost:3000');
});

interface User {
    id: number;
    name: string;
    email: string;
}

const users: User[] = [
    { id: 1, name: 'Alice', email: 'alice@example.com' }
];

async function handler(req: Request): Promise<Response> {
    const url = new URL(req.url);
    
    if (req.method === 'GET' && url.pathname === '/users') {
        return new Response(JSON.stringify(users), {
            headers: { 'Content-Type': 'application/json' }
        });
    }
    
    if (req.method === 'POST' && url.pathname === '/users') {
        const body = await req.json();
        const newUser: User = {
            id: users.length + 1,
            name: body.name,
            email: body.email
        };
        users.push(newUser);
        return new Response(JSON.stringify(newUser), { status: 201 });
    }
    
    return new Response('Not Found', { status: 404 });
}

Deno.serve({ port: 3000 }, handler);