NestJS

import "reflect-metadata"
import {
  Body,
  Controller,
  Get,
  Header,
  NotFoundException,
  Query,
  StreamableFile,
} from "@nestjs/common"
import { Post as HttpPost } from "@nestjs/common"
 
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" }
 
@Controller()
export class ImejisController {
  // 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.
  private readonly FORMATS = ["png", "jpeg", "webp", "pdf"]
 
  // Render on demand and return the image straight back. The render key stays
  // on the server, so it never reaches the browser — point an <img src> here.
  //
  // `?format=` decides what comes back — png · jpeg · webp · pdf. The type
  // goes on StreamableFile rather than in a @Header decorator, because a
  // decorator is fixed at class-definition time and this one has to follow the
  // format: a PDF labelled `image/png` is a file nothing will open.
  @Get("og")
  // Renders are deterministic, so cache aggressively at the edge/CDN — and
  // every request to the render API is one metered render.
  @Header("Cache-Control", "public, immutable, no-transform, max-age=31536000")
  async ogImage(
    @Query("title") title: string,
    @Query("subtitle") subtitle: string,
    @Query("format") requested: string,
  ) {
    const params = new URLSearchParams()
    if (this.FORMATS.includes(requested)) params.set("format", requested)
 
    const upstream = await fetch(`${BASE}/v1/${DESIGN_ID}?${params}`, {
      method: "POST",
      headers: HEADERS,
      body: JSON.stringify({
        "headline.text": title ?? "Hello from NestJS",
        "subtitle.text": subtitle ?? "",
      }),
    })
    if (!upstream.ok) throw new Error(`render failed: ${upstream.status}`)
    // StreamableFile, not a bare Buffer: Nest serialises a Buffer as JSON
    // ({"type":"Buffer","data":[…]}), which turns a 30KB PNG into 100KB of
    // numbers that no browser will render.
    return new StreamableFile(Buffer.from(await upstream.arrayBuffer()), {
      type: upstream.headers.get("content-type") ?? "image/jpeg",
    })
  }
}
 
// app.module.ts
// @Module({ controllers: [ImejisController] })
// export class AppModule {}

import "reflect-metadata"
import {
  Body,
  Controller,
  Get,
  Header,
  NotFoundException,
  Query,
  StreamableFile,
} from "@nestjs/common"
import { Post as HttpPost } from "@nestjs/common"
 
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" }
 
@Controller()
export class ImejisController {
  // 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.
  private readonly 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.
  private readonly SIZES: Record<string, string | null> = {
    og: null,
    story: process.env.IMEJIS_VARIATION_ID ?? "story",
  }
 
  @Get("og-size")
  @Header("Cache-Control", "public, immutable, no-transform, max-age=31536000")
  async ogSize(
    @Query("size") size: string,
    @Query("title") title: string,
    @Query("format") requested: string,
    @Query("quality") quality: string,
  ) {
    // A key that is absent is an unknown size; one that is `null` is the base
    // canvas, which is a render with no `variation` at all.
    const variation = this.SIZES[size ?? "og"]
    if (variation === undefined) {
      throw new NotFoundException(`unknown size: ${size}`)
    }
 
    const params = new URLSearchParams()
    if (variation) params.set("variation", variation)
    if (this.FORMATS.includes(requested)) params.set("format", requested)
    if (Number(quality) >= 1 && Number(quality) <= 100) {
      params.set("quality", quality)
    }
 
    const upstream = await fetch(`${BASE}/v1/${DESIGN_ID}?${params}`, {
      method: "POST",
      headers: HEADERS,
      body: JSON.stringify({ "headline.text": title ?? "Every size" }),
    })
    if (!upstream.ok) throw new Error(`render failed: ${upstream.status}`)
    return new StreamableFile(Buffer.from(await upstream.arrayBuffer()), {
      type: upstream.headers.get("content-type") ?? "image/jpeg",
    })
  }
}
 
// app.module.ts
// @Module({ controllers: [ImejisController] })
// export class AppModule {}

import "reflect-metadata"
import {
  Body,
  Controller,
  Get,
  Header,
  NotFoundException,
  Query,
  StreamableFile,
} from "@nestjs/common"
import { Post as HttpPost } from "@nestjs/common"
 
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" }
 
@Controller()
export class ImejisController {
  // 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.
  private readonly 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).
  @Get("og-url")
  async ogUrl(
    @Query("title") title: string,
    @Query("private") isPrivate: string,
    @Query("format") requested: string,
  ) {
    const delivery = isPrivate ? "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 (this.FORMATS.includes(requested)) params.set("format", requested)
    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": title ?? "Shared card" }),
    })
    const stored = await upstream.json()
    return {
      url: stored.url,
      format: stored.format,
      expiresAt: stored.expiresAt ?? null,
    }
  }
}
 
// app.module.ts
// @Module({ controllers: [ImejisController] })
// export class AppModule {}

import "reflect-metadata"
import {
  Body,
  Controller,
  Get,
  Header,
  NotFoundException,
  Query,
  StreamableFile,
} from "@nestjs/common"
import { Post as HttpPost } from "@nestjs/common"
 
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" }
 
@Controller()
export class ImejisController {
  // 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.
  private readonly 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.
  @HttpPost("cards")
  async cards(@Body() body: { rows?: { name: string; role: string }[] }) {
    const upstream = await fetch(`${BASE}/bulk`, {
      method: "POST",
      headers: HEADERS,
      body: JSON.stringify({
        designId: DESIGN_ID,
        delivery: "hosted",
        format: "png",
        data: (body.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) }
  }
}
 
// app.module.ts
// @Module({ controllers: [ImejisController] })
// export class AppModule {}

import "reflect-metadata"
import {
  Body,
  Controller,
  Get,
  Header,
  NotFoundException,
  Query,
  StreamableFile,
} from "@nestjs/common"
import { Post as HttpPost } from "@nestjs/common"
 
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" }
 
@Controller()
export class ImejisController {
  // 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.
  private readonly 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.
  @Get("card")
  @Header("Content-Type", "text/html")
  card(@Query("title") title: string) {
    const url = new URL(`${BASE}/v1/${DESIGN_ID}`)
    url.searchParams.set("dma-api-key", API_KEY)
    url.searchParams.set("headline.text", title ?? "Straight from a URL")
    return `<img src="${url}" width="1200" height="630" alt="Generated card" />`
  }
}
 
// app.module.ts
// @Module({ controllers: [ImejisController] })
// export class AppModule {}