10 Code Migration Prompts: Python 2→3, JavaScript→TypeScript, REST→GraphQL

You are a senior Python developer migrating a codebase from Python 2.7 to Python 3.10+. Convert the following Python 2 code to Python 3, following these rules:
1. Replace `print` statement with `print()` function.
2. Replace `xrange()` with `range()`.
3. Replace `dict.iteritems()` with `dict.items()`.
4. Use Python 3's `//` for integer division where floor division is intended.
5. Replace `unicode` with `str` and handle bytes explicitly with `b''`.
6. Replace `basestring` with `str`.
7. Use f-strings instead of `%` formatting where readability improves.
8. Keep the same function signatures and module-level structure.

Python 2 code:
```python
# legacy_utils.py
import urllib2
import urlparse

def fetch_data(url):
    request = urllib2.Request(url)
    response = urllib2.urlopen(request)
    return response.read()

def process_items(items):
    result = []
    for key, value in items.iteritems():
        if isinstance(value, unicode):
            value = value.encode('utf-8')
        result.append((key, value))
    return result

def calculate_average(numbers):
    total = sum(numbers)
    return total / len(numbers)

**Example Result:**
```python
# legacy_utils.py (Python 3)
import urllib.request
import urllib.parse

def fetch_data(url):
    request = urllib.request.Request(url)
    response = urllib.request.urlopen(request)
    return response.read()

def process_items(items):
    result = []
    for key, value in items.items():
        if isinstance(value, str):
            value = value.encode('utf-8')
        result.append((key, value))
    return result

def calculate_average(numbers):
    total = sum(numbers)
    return total / len(numbers)  # returns float; use // for int

Convert the following Python 2 exception handling to Python 3. In Python 3:
- Use `except Exception as e:` instead of `except Exception, e:`.
- Use `raise Exception('message') from original_error` to chain exceptions.
- The `sys.exc_info()` is still valid but prefer `traceback.format_exc()` for logging.

Python 2 code:
```python
def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError, e:
        print "Cannot divide by zero:", e
        return None

**Example Result:**
```python
def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError as e:
        print(f"Cannot divide by zero: {e}")
        return None

Migrate this Python 2 code to Python 3. In Python 3:
- All strings are Unicode by default.
- Use `b''` for bytes literals.
- Replace `unicode()` with `str()`.
- Use `.encode()` to convert str to bytes, `.decode()` to convert bytes to str.
- Replace `isinstance(s, basestring)` with `isinstance(s, str)`.

Python 2 code:
```python
def normalize_text(text):
    if isinstance(text, unicode):
        return text.lower()
    elif isinstance(text, str):
        return text.decode('utf-8').lower()
    else:
        raise TypeError('Expected string')

**Example Result:**
```python
def normalize_text(text):
    if isinstance(text, bytes):
        text = text.decode('utf-8')
    if isinstance(text, str):
        return text.lower()
    else:
        raise TypeError('Expected string or bytes')

Convert this JavaScript code to TypeScript with `strict: true`. Follow these rules:
1. Add explicit type annotations for all function parameters and return types.
2. Replace `var` with `const` or `let` as appropriate.
3. Define interfaces for any object shape that appears more than once.
4. Use `unknown` instead of `any` for values whose type cannot be determined.
5. Use `as const` for literal types.
6. Do not use `// @ts-ignore` or `as any` without a comment explaining why.
7. Keep the same logic and structure.

JavaScript code:
```javascript
function calculateTotal(items) {
    let total = 0;
    for (let i = 0; i < items.length; i++) {
        total += items[i].price * items[i].quantity;
    }
    return total;
}

function formatUser(user) {
    return `${user.firstName} ${user.lastName} (${user.email})`;
}

**Example Result:**
```typescript
interface LineItem {
    price: number;
    quantity: number;
}

interface User {
    firstName: string;
    lastName: string;
    email: string;
}

function calculateTotal(items: LineItem[]): number {
    let total = 0;
    for (let i = 0; i < items.length; i++) {
        total += items[i].price * items[i].quantity;
    }
    return total;
}

function formatUser(user: User): string {
    return `${user.firstName} ${user.lastName} (${user.email})`;
}

Convert this JavaScript utility to TypeScript. The function merges objects with dynamic keys. Use generics and index signatures to preserve type safety. Avoid `any`.

JavaScript code:
```javascript
function mergeObjects(a, b) {
    const result = {};
    for (let key in a) {
        if (a.hasOwnProperty(key)) {
            result[key] = a[key];
        }
    }
    for (let key in b) {
        if (b.hasOwnProperty(key)) {
            result[key] = b[key];
        }
    }
    return result;
}

**Example Result:**
```typescript
function mergeObjects<T extends Record<string, unknown>, U extends Record<string, unknown>>(a: T, b: U): T & U {
    const result = { ...a, ...b } as T & U;
    return result;
}

Convert this JavaScript class to TypeScript. Add access modifiers (`private`, `public`, `protected`) where appropriate. Use parameter properties. Include proper typing for all methods and properties.

JavaScript code:
```javascript
class ApiClient {
    constructor(baseUrl) {
        this.baseUrl = baseUrl;
        this.cache = {};
    }

    async get(endpoint) {
        if (this.cache[endpoint]) {
            return this.cache[endpoint];
        }
        const response = await fetch(`${this.baseUrl}${endpoint}`);
        const data = await response.json();
        this.cache[endpoint] = data;
        return data;
    }
}

**Example Result:**
```typescript
interface CacheData {
    [endpoint: string]: unknown;
}

class ApiClient {
    private baseUrl: string;
    private cache: CacheData = {};

    constructor(baseUrl: string) {
        this.baseUrl = baseUrl;
    }

    async get<T>(endpoint: string): Promise<T> {
        if (this.cache[endpoint]) {
            return this.cache[endpoint] as T;
        }
        const response = await fetch(`${this.baseUrl}${endpoint}`);
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        const data: T = await response.json();
        this.cache[endpoint] = data;
        return data;
    }
}

You are migrating a REST API to GraphQL. Given the following REST endpoints and their responses, generate a GraphQL schema (using SDL) and resolver stubs. The schema should:
- Create a `Query` type with fields for each GET endpoint.
- Create a `Mutation` type for POST, PUT, DELETE endpoints.
- Use proper types and avoid `JSON` scalar unless necessary.
- Include pagination arguments (`first`, `after`) for list endpoints.

REST endpoints:
- GET /users → returns list of {id, name, email}
- GET /users/:id → returns single user
- POST /users → creates user, body: {name, email}
- GET /users/:id/posts → returns list of posts for user: {id, title, body}

# schema.graphql
type Query {
  users(first: Int, after: String): UserConnection!
  user(id: ID!): User
}

type Mutation {
  createUser(input: CreateUserInput!): User!
}

type User {
  id: ID!
  name: String!
  email: String!
  posts(first: Int, after: String): PostConnection!
}

type Post {
  id: ID!
  title: String!
  body: String!
}

type UserConnection {
  edges: [UserEdge!]!
  pageInfo: PageInfo!
}

type UserEdge {
  node: User!
  cursor: String!
}

type PageInfo {
  hasNextPage: Boolean!
  endCursor: String
}

input CreateUserInput {
  name: String!
  email: String!
}

Write Apollo Server resolvers for the following GraphQL schema. Each resolver should call the corresponding REST endpoint using `fetch`. Handle errors by throwing a `GraphQLError`. Use DataLoader to batch requests where possible.

Schema:
- `Query.user(id: ID!): User` → calls GET /users/:id
- `Query.users(first: Int, after: String): UserConnection` → calls GET /users (with query params)
- `Mutation.createUser(input: CreateUserInput!): User` → calls POST /users

const { GraphQLError } = require('graphql');
const DataLoader = require('dataloader');

const userLoader = new DataLoader(async (ids) => {
    const responses = await Promise.all(ids.map(id => fetch(`http://rest-api/users/${id}`)));
    return Promise.all(responses.map(r => r.json()));
});

const resolvers = {
    Query: {
        user: async (_, { id }) => {
            try {
                return await userLoader.load(id);
            } catch (error) {
                throw new GraphQLError('Failed to fetch user', { extensions: { code: 'REST_ERROR' } });
            }
        },
        users: async (_, { first, after }) => {
            const url = new URL('http://rest-api/users');
            if (first) url.searchParams.set('limit', first);
            if (after) url.searchParams.set('offset', after);
            const response = await fetch(url.toString());
            const data = await response.json();
            return {
                edges: data.map(user => ({ node: user, cursor: Buffer.from(user.id).toString('base64') })),
                pageInfo: {
                    hasNextPage: data.length === first,
                    endCursor: data.length ? Buffer.from(data[data.length - 1].id).toString('base64') : null
                }
            };
        }
    },
    Mutation: {
        createUser: async (_, { input }) => {
            const response = await fetch('http://rest-api/users', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(input)
            });
            if (!response.ok) {
                throw new GraphQLError('Failed to create user', { extensions: { code: 'REST_ERROR' } });
            }
            return response.json();
        }
    }
};

You have a REST controller that returns users with their posts in a single endpoint. In GraphQL, you want to split this into separate resolvers. Write resolvers for `User.posts` that use DataLoader to batch the database queries. Assume you have a `getPostsByUserIds(ids: number[]): Promise<Post[]>` function.

REST controller (for reference):
```javascript
app.get('/users-with-posts', async (req, res) => {
    const users = await db.users.findAll();
    for (let user of users) {
        user.posts = await db.posts.findAll({ where: { userId: user.id } });
    }
    res.json(users);
});

**Example Result:**
```javascript
const DataLoader = require('dataloader');

const postsByUserLoader = new DataLoader(async (userIds) => {
    const posts = await getPostsByUserIds(userIds);
    const grouped = userIds.map(id => posts.filter(post => post.userId === id));
    return grouped;
});

const resolvers = {
    User: {
        posts: async (parent) => {
            return postsByUserLoader.load(parent.id);
        }
    }
};

Write a GraphQL mutation `createPost` that replaces the REST endpoint `POST /posts`. The resolver should:
1. Validate input (title must be non-empty, body max 1000 chars).
2. Call a function `db.createPost(data)` that returns the new post.
3. Return the created post or throw a `UserInputError` with validation details.
4. Include the mutation definition in SDL.

REST equivalent:
```javascript
app.post('/posts', (req, res) => {
    const { title, body, userId } = req.body;
    if (!title || title.trim() === '') {
        return res.status(400).json({ error: 'Title is required' });
    }
    if (body.length > 1000) {
        return res.status(400).json({ error: 'Body too long' });
    }
    const post = db.createPost({ title, body, userId });
    res.status(201).json(post);
});

**Example Result:**

```graphql
# SDL
type Mutation {
  createPost(input: CreatePostInput!): Post!
}

input CreatePostInput {
  title: String!
  body: String!
  userId: ID!
}

// Resolver
const { UserInputError } = require('apollo-server-express');

const resolvers = {
    Mutation: {
        createPost: async (_, { input }) => {
            const errors = [];
            if (!input.title || input.title.trim() === '') {
                errors.push({ field: 'title', message: 'Title is required' });
            }
            if (input.body.length > 1000) {
                errors.push({ field: 'body', message: 'Body must be at most 1000 characters' });
            }
            if (errors.length > 0) {
                throw new UserInputError('Validation failed', { invalidArgs: errors });
            }
            const post = await db.createPost({ title: input.title, body: input.body, userId: input.userId });
            return post;
        }
    }
};