5 промтов для миграции кода: Python 2→3, JavaScript→TypeScript, REST→GraphQL

Ты — senior Python-разработчик. Перепиши следующий код с Python 2 на Python 3. Учти:
- Замени все `unicode()` на `str()`
- Для строковых литералов с `u''` убери префикс `u`
- Замени `xrange` на `range`
- Замени `print` statement на `print()` функцию
- Для работы с файлами используй `open()` с явным указанием кодировки (encoding='utf-8')
- Проверь, что используется `//` для целочисленного деления, если нужно

Исходный код:
```python
# Python 2
import urllib2
import sys
reload(sys)
sys.setdefaultencoding('utf8')

def read_data(url):
    response = urllib2.urlopen(url)
    data = response.read()
    return unicode(data, 'utf-8')

def process(items):
    result = []
    for i in xrange(len(items)):
        if isinstance(items[i], unicode):
            result.append(items[i].encode('utf-8'))
        else:
            result.append(items[i])
    return result

**Пример вывода (сокращённый):**
```python
# Python 3
import urllib.request

def read_data(url):
    response = urllib.request.urlopen(url)
    data = response.read()
    return data.decode('utf-8')

def process(items):
    result = []
    for i in range(len(items)):
        if isinstance(items[i], str):
            result.append(items[i])
        else:
            result.append(items[i])
    return result

Ты — senior TypeScript-разработчик. Конвертируй следующий JavaScript код в TypeScript. Правила:
- Добавь типы для всех параметров функций и возвращаемых значений
- Если тип невозможно вывести из контекста, используй `unknown` вместо `any`, но только если это безопасно
- Для объектов создай интерфейсы
- Для массивов используй `Array<Тип>` или `Тип[]`
- Замени `var` на `const` или `let`
- Не используй `@ts-ignore` и `@ts-nocheck`

Исходный код:
```javascript
function fetchUser(id) {
    return fetch('/api/users/' + id)
        .then(response => response.json())
        .then(data => {
            return {
                id: data.id,
                name: data.name,
                email: data.email
            };
        });
}

function printUser(user) {
    console.log(user.name + ' (' + user.email + ')');
}

**Пример вывода:**
```typescript
interface User {
    id: number;
    name: string;
    email: string;
}

async function fetchUser(id: number): Promise<User> {
    const response = await fetch(`/api/users/${id}`);
    const data = await response.json() as User;
    return {
        id: data.id,
        name: data.name,
        email: data.email
    };
}

function printUser(user: User): void {
    console.log(`${user.name} (${user.email})`);
}

Ты — senior backend-разработчик. Перепиши следующий REST-эндпоинт (Express.js) как GraphQL-резолвер для Apollo Server. Учти:
- Создай GraphQL-схему (typeDefs) с соответствующими типами
- Добавь резолвер для query, который принимает те же параметры
- Используй те же вызовы к базе данных (предположи, что есть Prisma-клиент `prisma`)
- Обработай ошибки через `GraphQLError`

Исходный REST-код:
```javascript
// Express route
app.get('/api/users/:id/orders', async (req, res) => {
    try {
        const userId = parseInt(req.params.id);
        const orders = await prisma.order.findMany({
            where: { userId },
            include: { items: true }
        });
        res.json(orders);
    } catch (error) {
        res.status(500).json({ error: 'Failed to fetch orders' });
    }
});

**Пример вывода:**
```graphql
# typeDefs
type Order {
    id: ID!
    userId: Int!
    items: [OrderItem!]!
    createdAt: String
}

type OrderItem {
    id: ID!
    productName: String!
    quantity: Int!
    price: Float!
}

type Query {
    userOrders(userId: Int!): [Order!]!
}

// resolver
const resolvers = {
    Query: {
        userOrders: async (_, { userId }, context) => {
            try {
                const orders = await prisma.order.findMany({
                    where: { userId },
                    include: { items: true }
                });
                return orders;
            } catch (error) {
                throw new GraphQLError('Failed to fetch orders', {
                    extensions: { code: 'INTERNAL_SERVER_ERROR' }
                });
            }
        }
    }
};

Ты — DBA с 10-летним опытом. Перепиши следующий SQL-запрос, используя подзапросы вместо JOIN. Сохрани ту же логику и результат. Используй синтаксис PostgreSQL.

Исходный запрос:
```sql
SELECT u.name, o.total
FROM users u
JOIN orders o ON u.id = o.user_id
WHERE o.status = 'completed';

**Пример вывода:**
```sql
SELECT u.name,
    (SELECT SUM(o.total) FROM orders o WHERE o.user_id = u.id AND o.status = 'completed') as total
FROM users u
WHERE EXISTS (
    SELECT 1 FROM orders o WHERE o.user_id = u.id AND o.status = 'completed'
);

Ты — senior Node.js разработчик. Перепиши следующий код с колбэками на async/await. Используй `fs.promises` вместо `fs`. Обработай ошибки через try/catch. Не используй `util.promisify` — только нативные промисы.

Исходный код:
```javascript
const fs = require('fs');

function readConfig(callback) {
    fs.readFile('/etc/config.json', 'utf8', (err, data) => {
        if (err) {
            callback(err);
            return;
        }
        try {
            const config = JSON.parse(data);
            callback(null, config);
        } catch (parseErr) {
            callback(parseErr);
        }
    });
}

**Пример вывода:**
```javascript
import { promises as fs } from 'fs';

async function readConfig(): Promise<object> {
    try {
        const data = await fs.readFile('/etc/config.json', 'utf8');
        return JSON.parse(data);
    } catch (error) {
        throw new Error(`Failed to read config: ${error.message}`);
    }
}