Fastify

import Fastify from "fastify"
 
const app = Fastify()
 
const API_KEY = process.env.IMEJIS_API_KEY
const DESIGN_ID = process.env.IMEJIS_DESIGN_ID
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
const HEADERS = { "dma-api-key": API_KEY, "Content-Type": "application/json" }
// The formats the render API accepts. The routes below pass `?format=`
// through when one is asked for; with none, the render host's default (jpeg)
// applies.
const FORMATS = ["png", "jpeg", "webp", "pdf"]
 
// 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> at this.
//
// `?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.
app.get("/og", async (request, reply) => {
  const params = new URLSearchParams()
  if (FORMATS.includes(request.query.format)) {
    params.set("format", request.query.format)
  }
 
  const upstream = await fetch(`${BASE}/v1/${DESIGN_ID}?${params}`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({
      "headline.text": request.query.title ?? "Hello from Fastify",
      "subtitle.text": request.query.subtitle ?? "",
    }),
  })
  if (!upstream.ok) {
    return reply.code(502).send({ error: `render failed: ${upstream.status}` })
  }
  return reply
    .type(upstream.headers.get("content-type") ?? "image/jpeg")
    // Cache it: the same query renders the same image, and every request to
    // the render API is one metered render.
    .header("Cache-Control", "public, immutable, no-transform, max-age=31536000")
    .send(Buffer.from(await upstream.arrayBuffer()))
})
 
await app.listen({ port: 3000 })
console.log("listening on http://localhost:3000")

import Fastify from "fastify"
 
const app = Fastify()
 
const API_KEY = process.env.IMEJIS_API_KEY
const DESIGN_ID = process.env.IMEJIS_DESIGN_ID
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
const HEADERS = { "dma-api-key": API_KEY, "Content-Type": "application/json" }
// The formats the render API accepts. The routes below pass `?format=`
// through when one is asked for; with none, the render host's default (jpeg)
// applies.
const FORMATS = ["png", "jpeg", "webp", "pdf"]
 
// 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 SIZES = { og: null, story: process.env.IMEJIS_VARIATION_ID ?? "story" }
 
app.get("/og-size", async (request, reply) => {
  const size = request.query.size ?? "og"
  if (!(size in SIZES)) {
    return reply.code(404).send({ error: `unknown size: ${size}` })
  }
 
  const params = new URLSearchParams()
  if (SIZES[size]) params.set("variation", SIZES[size])
  if (FORMATS.includes(request.query.format)) {
    params.set("format", request.query.format)
  }
  const quality = Number(request.query.quality)
  if (quality >= 1 && quality <= 100) params.set("quality", String(quality))
 
  const upstream = await fetch(`${BASE}/v1/${DESIGN_ID}?${params}`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({
      "headline.text": request.query.title ?? "Every size",
    }),
  })
  if (!upstream.ok) {
    return reply.code(502).send({ error: `render failed: ${upstream.status}` })
  }
  return reply
    .type(upstream.headers.get("content-type") ?? "image/jpeg")
    .header("Cache-Control", "public, immutable, no-transform, max-age=31536000")
    .send(Buffer.from(await upstream.arrayBuffer()))
})
 
await app.listen({ port: 3000 })
console.log("listening on http://localhost:3000")

import Fastify from "fastify"
 
const app = Fastify()
 
const API_KEY = process.env.IMEJIS_API_KEY
const DESIGN_ID = process.env.IMEJIS_DESIGN_ID
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
const HEADERS = { "dma-api-key": API_KEY, "Content-Type": "application/json" }
// The formats the render API accepts. The routes below pass `?format=`
// through when one is asked for; with none, the render host's default (jpeg)
// applies.
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).
app.get("/og-url", async (request) => {
  const delivery = request.query.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.
  if (FORMATS.includes(request.query.format)) {
    params.set("format", request.query.format)
  }
  if (delivery === "signed") params.set("expiresIn", "30")
 
  const upstream = await fetch(`${BASE}/v1/${DESIGN_ID}?${params}`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({ "headline.text": request.query.title ?? "Shared card" }),
  })
  const stored = await upstream.json()
  return {
    url: stored.url,
    format: stored.format,
    expiresAt: stored.expiresAt ?? null,
  }
})
 
await app.listen({ port: 3000 })
console.log("listening on http://localhost:3000")

import Fastify from "fastify"
 
const app = Fastify()
 
const API_KEY = process.env.IMEJIS_API_KEY
const DESIGN_ID = process.env.IMEJIS_DESIGN_ID
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
const HEADERS = { "dma-api-key": API_KEY, "Content-Type": "application/json" }
// The formats the render API accepts. The routes below pass `?format=`
// through when one is asked for; with none, the render host's default (jpeg)
// applies.
const FORMATS = ["png", "jpeg", "webp", "pdf"]
 
// One POST renders many images and returns a URL for each, in the order sent —
// a row per record, or one per size.
app.post("/cards", async (request) => {
  const rows = request.body.rows ?? []
  const upstream = await fetch(`${BASE}/bulk`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({
      designId: DESIGN_ID,
      delivery: "hosted",
      format: "png",
      data: rows.map((row) => ({
        "headline.text": row.name,
        "subtitle.text": row.role,
      })),
    }),
  })
  const bulk = await upstream.json()
  return { summary: bulk.summary, urls: bulk.results.map((r) => r.url ?? null) }
})
 
await app.listen({ port: 3000 })
console.log("listening on http://localhost:3000")

import Fastify from "fastify"
 
const app = Fastify()
 
const API_KEY = process.env.IMEJIS_API_KEY
const DESIGN_ID = process.env.IMEJIS_DESIGN_ID
const BASE = process.env.IMEJIS_RENDER_URL ?? "https://render.imejis.io"
const HEADERS = { "dma-api-key": API_KEY, "Content-Type": "application/json" }
// The formats the render API accepts. The routes below pass `?format=`
// through when one is asked for; with none, the render host's default (jpeg)
// applies.
const FORMATS = ["png", "jpeg", "webp", "pdf"]
 
// For a PUBLIC design you can skip the proxy and point an <img> straight at
// the render URL. Keep the proxy whenever the key must stay private — that is
// the right default, and what /og above is for.
app.get("/card", async (request, reply) => {
  const url = new URL(`${BASE}/v1/${DESIGN_ID}`)
  url.searchParams.set("dma-api-key", API_KEY)
  url.searchParams.set("headline.text", request.query.title ?? "Straight from a URL")
  return reply
    .type("text/html")
    .send(`<img src="${url}" width="1200" height="630" alt="Generated card" />`)
})
 
await app.listen({ port: 3000 })
console.log("listening on http://localhost:3000")