Remix

IMEJIS_API_KEY=your_api_key
IMEJIS_DESIGN_ID=your_design_id

import type { LoaderFunctionArgs } from "@remix-run/node"
 
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
 
// A resource route: no component, just a response. Renders on demand and
// streams the image straight back, so the key stays on the server — point an
// <img src>, or an og:image, at /og.
//
// `?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.
const FORMATS = ["png", "jpeg", "webp", "pdf"]
 
export async function loader({ request }: LoaderFunctionArgs) {
  const url = new URL(request.url)
  const title = url.searchParams.get("title") ?? "Hello from Remix"
  const params = new URLSearchParams()
  const requested = url.searchParams.get("format") ?? ""
  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": url.searchParams.get("subtitle") ?? "",
      }),
    }
  )
  if (!upstream.ok) {
    throw new Response(`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 { LoaderFunctionArgs } from "@remix-run/node"
 
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 loader({ request }: LoaderFunctionArgs) {
  const url = new URL(request.url)
  const size = url.searchParams.get("size") ?? "og"
  if (!(size in SIZES)) {
    throw new Response(`unknown size: ${size}`, { status: 404 })
  }
 
  const params = new URLSearchParams()
  const variation = SIZES[size]
  if (variation) params.set("variation", variation)
  const requested = url.searchParams.get("format") ?? ""
  if (FORMATS.includes(requested)) params.set("format", requested)
  const quality = Number(url.searchParams.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": url.searchParams.get("title") ?? "Every size",
      }),
    }
  )
  if (!upstream.ok) {
    throw new Response(`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 { json, type LoaderFunctionArgs } from "@remix-run/node"
 
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
 
// Ask for a stored URL instead of bytes. `hosted` is public and permanent;
// `signed` is private and expires (`expiresIn` is minutes).
export async function loader({ request }: LoaderFunctionArgs) {
  const url = new URL(request.url)
  const delivery = url.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 = url.searchParams.get("format") ?? ""
  if (["png", "jpeg", "webp", "pdf"].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": url.searchParams.get("title") ?? "Shared card",
      }),
    }
  )
  // { url, format, file: { size }, expiresAt (signed only) }
  const stored = await upstream.json()
 
  return json({
    url: stored.url,
    format: stored.format,
    expiresAt: stored.expiresAt ?? null,
  })
}

import { json, type ActionFunctionArgs } from "@remix-run/node"
 
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
 
// `action` is the POST half of a resource route. One call renders many images
// and returns a URL for each, in the order sent — a row per record, or one per
// size.
export async function action({ request }: ActionFunctionArgs) {
  const { rows = [] } = await request.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 json({
    summary: bulk.summary,
    urls: bulk.results.map((r: { url?: string }) => r.url ?? null),
  })
}

import { json, type LoaderFunctionArgs, type MetaFunction } from "@remix-run/node"
import { useLoaderData } from "@remix-run/react"
 
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
 
export async function loader({ request }: LoaderFunctionArgs) {
  const url = new URL(request.url)
  const title = url.searchParams.get("title") ?? "Straight from a URL"
 
  // og:image points at YOUR OWN route (the proxy above), so crawlers and
  // social platforms fetch your domain and the key stays server-side. They
  // need an absolute URL, which the request gives you.
  const ogImage = `${url.origin}/og?title=${encodeURIComponent(title)}`
 
  // For a PUBLIC design you can skip the proxy and point an <img> straight at
  // the render URL. The loader runs on the server, but the URL it returns ends
  // up in the markup — so only do this with a key you are happy to expose.
  // Keep the proxy whenever it must stay private: that is the right default.
  const direct = new URL(`${BASE}/v1/${process.env.IMEJIS_DESIGN_ID}`)
  direct.searchParams.set("dma-api-key", process.env.IMEJIS_API_KEY as string)
  direct.searchParams.set("headline.text", title)
 
  return json({ title, ogImage, src: direct.toString() })
}
 
export const meta: MetaFunction<typeof loader> = ({ data }) => [
  { title: data?.title },
  { property: "og:image", content: data?.ogImage },
  { name: "twitter:card", content: "summary_large_image" },
]
 
export default function Card() {
  const { src, title } = useLoaderData<typeof loader>()
 
  return <img src={src} width={1200} height={630} alt={`Card for ${title}`} />
}