Code Generation Head-to-Head

import fetch, { Response } from 'node-fetch'; // polyfill for Node.js <18

interface RetryConfig {
  maxRetries: number;
  baseDelay: number;
  maxDelay: number;
  retryOnStatus: number[];
  timeoutMs: number;
}

const DEFAULT_CONFIG: RetryConfig = {
  maxRetries: 3,
  baseDelay: 300,
  maxDelay: 10000,
  retryOnStatus: [429, 500, 502, 503, 504],
  timeoutMs: 30000,
};

export interface ApiResponse<T> {
  data: T | null;
  error: string | null;
  attempts: number;
}

function sleep(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

function getBackoffDelay(attempt: number, config: RetryConfig): number {
  const exponential = config.baseDelay * Math.pow(2, attempt);
  const jittered = exponential * (0.5 + Math.random() * 0.5);
  return Math.min(jittered, config.maxDelay);
}

export async function fetchUserData<T>(
  url: string,
  options: RequestInit = {},
  config: Partial<RetryConfig> = {},
): Promise<ApiResponse<T>> {
  const cfg: RetryConfig = { ...DEFAULT_CONFIG, ...config };
  let lastError: string = 'Unknown error';

  for (let attempt = 0; attempt <= cfg.maxRetries; attempt++) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), cfg.timeoutMs);

    try {
      const response: Response = await fetch(url, {
        ...options,
        signal: controller.signal,
      });
      clearTimeout(timeoutId);

      if (!cfg.retryOnStatus.includes(response.status) && !response.ok) {
        return {
          data: null,
          error: `HTTP ${response.status}: ${response.statusText}`,
          attempts: attempt + 1,
        };
      }

      if (response.ok) {
        const data = (await response.json()) as T;
        return { data, error: null, attempts: attempt + 1 };
      }

      lastError = `HTTP ${response.status} — retrying (${attempt + 1}/${cfg.maxRetries + 1})`;
    } catch (err) {
      clearTimeout(timeoutId);
      lastError = err instanceof Error ? err.message : 'Network error';
      if (err instanceof Error && err.name === 'AbortError') {
        lastError = `Request timed out after ${cfg.timeoutMs}ms`;
      }
    }

    if (attempt < cfg.maxRetries) {
      await sleep(getBackoffDelay(attempt, cfg));
    }
  }

  return { data: null, error: lastError, attempts: cfg.maxRetries + 1 };
}

from flask import Flask, jsonify, request
from flask_sqlalchemy import SQLAlchemy
from marshmallow import Schema, fields, ValidationError
from datetime import datetime
import os

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'sqlite:///blog.db')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)


class BlogPost(db.Model):
    __tablename__ = 'posts'
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)
    author = db.Column(db.String(100), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

    def to_dict(self):
        return {
            'id': self.id, 'title': self.title, 'content': self.content,
            'author': self.author,
            'created_at': self.created_at.isoformat(),
            'updated_at': self.updated_at.isoformat(),
        }


class PostSchema(Schema):
    title = fields.Str(required=True, validate=lambda s: len(s) > 0)
    content = fields.Str(required=True)
    author = fields.Str(required=True)

post_schema = PostSchema()
partial_schema = PostSchema(partial=True)


@app.route('/posts', methods=['POST'])
def create_post():
    try:
        data = post_schema.load(request.get_json() or {})
    except ValidationError as e:
        return jsonify({'errors': e.messages}), 400
    post = BlogPost(**data)
    db.session.add(post)
    db.session.commit()
    return jsonify(post.to_dict()), 201


@app.route('/posts', methods=['GET'])
def list_posts():
    page = request.args.get('page', 1, type=int)
    per_page = request.args.get('per_page', 20, type=int)
    paginated = BlogPost.query.order_by(BlogPost.created_at.desc()).paginate(
        page=page, per_page=per_page, error_out=False)
    return jsonify({
        'posts': [p.to_dict() for p in paginated.items],
        'total': paginated.total,
        'pages': paginated.pages,
        'current_page': page,
    }), 200


@app.route('/posts/<int:post_id>', methods=['GET'])
def get_post(post_id):
    post = db.get_or_404(BlogPost, post_id)
    return jsonify(post.to_dict()), 200


@app.route('/posts/<int:post_id>', methods=['PUT'])
def update_post(post_id):
    post = db.get_or_404(BlogPost, post_id)
    try:
        data = partial_schema.load(request.get_json() or {})
    except ValidationError as e:
        return jsonify({'errors': e.messages}), 400
    for key, value in data.items():
        setattr(post, key, value)
    db.session.commit()
    return jsonify(post.to_dict()), 200


@app.route('/posts/<int:post_id>', methods=['DELETE'])
def delete_post(post_id):
    post = db.get_or_404(BlogPost, post_id)
    db.session.delete(post)
    db.session.commit()
    return '', 204


if __name__ == '__main__':
    with app.app_context():
        db.create_all()
    app.run(debug=True)