AI Image Generator Using API: Complete Node.js Guide

import express from 'express';
import 'dotenv/config';

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

app.post('/api/generate-image', async (req, res) => {
  const { prompt } = req.body;

  if (!prompt || prompt.trim().length === 0) {
    return res.status(400).json({ error: 'Prompt is required' });
  }

  try {
    const response = await fetch('https://api.openai.com/v1/images/generations', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`, // server-side only
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        model: 'dall-e-3',
        prompt: prompt,
        n: 1,
        size: '1024x1024'
      })
    });

    if (!response.ok) {
      const errorBody = await response.json();
      return res.status(response.status).json({ error: errorBody.error?.message || 'Generation failed' });
    }

    const data = await response.json();
    res.json({ imageUrl: data.data[0].url });

  } catch (err) {
    console.error('Image generation error:', err);
    res.status(500).json({ error: 'Internal server error' });
  }
});

function normalizeImageResponse(providerResponse) {
  // Case 1: provider returns a hosted URL directly
  if (providerResponse.url) {
    return { type: 'url', value: providerResponse.url };
  }

  // Case 2: provider returns base64-encoded image data
  if (providerResponse.b64_json) {
    return { type: 'base64', value: providerResponse.b64_json };
  }

  // Case 3: provider returns an array of output URLs (common with Replicate)
  if (Array.isArray(providerResponse) && providerResponse[0]) {
    return { type: 'url', value: providerResponse[0] };
  }

  throw new Error('Unrecognized response format from image provider');
}

function saveBase64Image(base64String, outputPath) {
  const buffer = Buffer.from(base64String, 'base64');
  fs.writeFileSync(outputPath, buffer);
}

async function generateWithRetry(prompt, maxRetries = 2) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const response = await fetch(IMAGE_API_URL, {
      method: 'POST',
      headers: authHeaders,
      body: JSON.stringify({ prompt })
    });

    if (response.status === 429) {
      // Rate limited, respect Retry-After if the provider sends one
      const retryAfter = parseInt(response.headers.get('retry-after') || '2');
      await new Promise(r => setTimeout(r, retryAfter * 1000));
      continue;
    }

    if (response.status === 400) {
      const body = await response.json();
      // Don't retry a bad request, log it and fail fast
      throw new Error(`Bad request: ${body.error?.message || 'invalid payload'}`);
    }

    if (response.ok) {
      return await response.json();
    }
  }

  throw new Error('Max retries exceeded');
}

async function generateOgImageForArticle(articleTitle, slug) {
  const prompt = `Minimalist blog header image representing: ${articleTitle}. `
    + 'Clean, professional, no text, wide aspect ratio.';

  const result = await generateWithRetry(prompt);
  const normalized = normalizeImageResponse(result.data[0]);

  const outputPath = `./public/og-images/${slug}.jpg`;

  if (normalized.type === 'base64') {
    saveBase64Image(normalized.value, outputPath);
  } else {
    const imageResponse = await fetch(normalized.value);
    const buffer = Buffer.from(await imageResponse.arrayBuffer());
    fs.writeFileSync(outputPath, buffer);
  }

  return `/og-images/${slug}.jpg`; // use this as og:image
}