Next.js

IMEJIS_API_KEY=your_api_key
IMEJIS_DESIGN_ID=your_design_id

import type { NextRequest } from "next/server"
 
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
 
// Render on demand and stream the image straight back. The render key stays on
// the server, so it never reaches the browser — point an <img src>, or an
// og:image, at this route.
//
// `?format=` decides what comes back — png · jpeg · webp · pdf — and with no
// format the render host's default (jpeg) applies. Either way the response
// carries whatever type the render API set, passed straight through: a PDF
// labelled `image/jpeg` is a file the browser, the email client and Slack all
// refuse to open.
// The formats the render API accepts. The routes pass `?format=` through when
// one is asked for; with none, the render host's default (jpeg) applies.
const FORMATS = ["png", "jpeg", "webp", "pdf"]
 
export async function GET(req: NextRequest) {
  const title = req.nextUrl.searchParams.get("title") ?? "Hello from Next.js"
  const requested = req.nextUrl.searchParams.get("format") ?? ""
  const params = new URLSearchParams()
  if (FORMATS.includes(requested)) params.set("format", requested)
 
  const upstream = await fetch(
    `${BASE}/v1/${process.env.IMEJIS_DESIGN_ID}?${params}`,
    {
      method: "POST",
      headers: {
        "dma-api-key": process.env.IMEJIS_API_KEY as string,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        "headline.text": title,
        "subtitle.text": req.nextUrl.searchParams.get("subtitle") ?? "",
      }),
    }
  )
  if (!upstream.ok) {
    return Response.json(
      { error: `render failed: ${upstream.status}` },
      { status: 502 }
    )
  }
 
  // Pass the body straight through — no buffering of the whole image.
  return new Response(upstream.body, {
    headers: {
      "Content-Type": upstream.headers.get("content-type") ?? "image/jpeg",
      // Renders are deterministic, so cache aggressively at the edge/CDN —
      // and every request to the render API is one metered render.
      "Cache-Control": "public, immutable, no-transform, max-age=31536000",
    },
  })
}

import type { NextRequest } from "next/server"
 
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
 
// One design, several canvases — an OG image, a square post, a vertical
// story. `?variation=<id>` picks which one you get; with none you get the base
// size. Map YOUR OWN size names to the ids (the design's Share / API panel
// lists them) so a page asks for "story", not for an id.
//
// `?quality=` trades file size for fidelity on JPEG only — png, webp and pdf
// ignore it.
const FORMATS = ["png", "jpeg", "webp", "pdf"]
const SIZES: Record<string, string | null> = {
  og: null,
  story: process.env.IMEJIS_VARIATION_ID ?? "story",
}
 
export async function GET(req: NextRequest) {
  const query = req.nextUrl.searchParams
  const size = query.get("size") ?? "og"
  if (!(size in SIZES)) {
    return Response.json({ error: `unknown size: ${size}` }, { status: 404 })
  }
 
  const params = new URLSearchParams()
  const variation = SIZES[size]
  if (variation) params.set("variation", variation)
  const requested = query.get("format") ?? ""
  if (FORMATS.includes(requested)) params.set("format", requested)
  const quality = Number(query.get("quality"))
  if (quality >= 1 && quality <= 100) params.set("quality", String(quality))
 
  const upstream = await fetch(
    `${BASE}/v1/${process.env.IMEJIS_DESIGN_ID}?${params}`,
    {
      method: "POST",
      headers: {
        "dma-api-key": process.env.IMEJIS_API_KEY as string,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ "headline.text": query.get("title") ?? "Every size" }),
    }
  )
  if (!upstream.ok) {
    return Response.json(
      { error: `render failed: ${upstream.status}` },
      { status: 502 }
    )
  }
 
  return new Response(upstream.body, {
    headers: {
      "Content-Type": upstream.headers.get("content-type") ?? "image/jpeg",
      "Cache-Control": "public, immutable, no-transform, max-age=31536000",
    },
  })
}

import type { NextRequest } from "next/server"
 
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
const FORMATS = ["png", "jpeg", "webp", "pdf"]
 
// Ask for a stored URL instead of bytes. `hosted` is public and permanent;
// `signed` is private and expires (`expiresIn` is minutes).
export async function GET(req: NextRequest) {
  const delivery = req.nextUrl.searchParams.get("private") ? "signed" : "hosted"
  const params = new URLSearchParams({ delivery })
  // The stored URL carries the extension of the format it was rendered in, so
  // pass the format through here too — a recipient that sniffs by extension
  // (an email client, a Slack unfurl) needs `.pdf` to say pdf.
  const requested = req.nextUrl.searchParams.get("format") ?? ""
  if (FORMATS.includes(requested)) params.set("format", requested)
  if (delivery === "signed") params.set("expiresIn", "30")
 
  const upstream = await fetch(
    `${BASE}/v1/${process.env.IMEJIS_DESIGN_ID}?${params}`,
    {
      method: "POST",
      headers: {
        "dma-api-key": process.env.IMEJIS_API_KEY as string,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        "headline.text": req.nextUrl.searchParams.get("title") ?? "Shared card",
      }),
    }
  )
  // { url, format, file: { size }, expiresAt (signed only) }
  const stored = await upstream.json()
 
  return Response.json({
    url: stored.url,
    format: stored.format,
    expiresAt: stored.expiresAt ?? null,
  })
}

import type { NextRequest } from "next/server"
 
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
 
// One POST renders many images and returns a URL for each, in the order sent —
// a row per record, or one per size.
export async function POST(req: NextRequest) {
  const { rows = [] } = await req.json()
 
  const upstream = await fetch(`${BASE}/bulk`, {
    method: "POST",
    headers: {
      "dma-api-key": process.env.IMEJIS_API_KEY as string,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      designId: process.env.IMEJIS_DESIGN_ID,
      delivery: "hosted",
      format: "png",
      data: rows.map((row: { name: string; role?: string }) => ({
        "headline.text": row.name,
        "subtitle.text": row.role ?? "",
      })),
    }),
  })
  const bulk = await upstream.json()
 
  return Response.json({
    summary: bulk.summary,
    urls: bulk.results.map((r: { url?: string }) => r.url ?? null),
  })
}

import type { Metadata } from "next"
 
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
const SITE = process.env.SITE_URL ?? "http://localhost:3000"
 
type Props = { searchParams: Promise<{ title?: string }> }
 
// og:image points at YOUR OWN route (the proxy above), so crawlers and social
// platforms fetch your domain and the key stays server-side. This is the
// pattern to use for link previews.
export async function generateMetadata({
  searchParams,
}: Props): Promise<Metadata> {
  const { title = "Straight from a URL" } = await searchParams
  const ogImage = `${SITE}/og?title=${encodeURIComponent(title)}`
 
  return {
    title,
    openGraph: { images: [ogImage] },
    twitter: { card: "summary_large_image", images: [ogImage] },
  }
}
 
export default async function Page({ searchParams }: Props) {
  const { title = "Straight from a URL" } = await searchParams
 
  // For a PUBLIC design you can skip the proxy and point an <img> straight at
  // the render URL — but the key then ships in the HTML. Keep the proxy
  // whenever the key must stay private: that is the right default, and what
  // /og above is for.
  const url = new URL(`${BASE}/v1/${process.env.IMEJIS_DESIGN_ID}`)
  url.searchParams.set("dma-api-key", process.env.IMEJIS_API_KEY as string)
  url.searchParams.set("headline.text", title)
 
  return (
    <img
      src={url.toString()}
      width={1200}
      height={630}
      alt={`Card for ${title}`}
    />
  )
}