Ruby on Rails

IMEJIS_API_KEY=your_api_key
IMEJIS_DESIGN_ID=your_design_id

Rails.application.routes.draw do
  get "og", to: "og#show"
  get "og-size", to: "og#og_size"
  get "og-url", to: "og#stored_url"
  post "og-bulk", to: "og#og_bulk"
  get "card", to: "og#card"
end

require "json"
require "net/http"
 
class OgController < ApplicationController
  BASE = ENV.fetch("IMEJIS_RENDER_URL", "https://render.imejis.io")
  HEADERS = {
    "dma-api-key" => ENV["IMEJIS_API_KEY"],
    "Content-Type" => "application/json"
  }.freeze
 
  # The formats the render API accepts. The actions below pass `?format=`
  # through when one is asked for; with none, the render host's default (jpeg)
  # applies.
  FORMATS = %w[png jpeg webp pdf].freeze
 
  # Render on demand and send the image straight back. The key stays on the
  # server, so it never reaches the browser — point an <img src>, or an
  # og:image, at this action.
  #
  # `?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.
  def show
    # request.query_parameters, not params: Rails reads params[:format] as the
    # RESPONSE format, so `?format=pdf` would also tell Rails to render a pdf
    # template and raise UnknownFormat before this action could answer.
    requested = request.query_parameters["format"]
    query = FORMATS.include?(requested) ? "?format=#{requested}" : ""
 
    uri = URI("#{BASE}/v1/#{ENV['IMEJIS_DESIGN_ID']}#{query}")
    upstream = Net::HTTP.post(uri, {
      "headline.text" => params[:title] || "Hello from Rails",
      "subtitle.text" => params[:subtitle].to_s
    }.to_json, HEADERS)
    return head :bad_gateway unless upstream.is_a?(Net::HTTPSuccess)
 
    # Renders are deterministic, so cache aggressively at the edge/CDN — and
    # every request to the render API is one metered render.
    headers["Cache-Control"] = "public, immutable, no-transform, max-age=31536000"
    send_data upstream.body,
              type: upstream["content-type"] || "image/jpeg",
              disposition: "inline"
  end
end

require "json"
require "net/http"
 
class OgController < ApplicationController
  BASE = ENV.fetch("IMEJIS_RENDER_URL", "https://render.imejis.io")
  HEADERS = {
    "dma-api-key" => ENV["IMEJIS_API_KEY"],
    "Content-Type" => "application/json"
  }.freeze
 
  # The formats the render API accepts. The actions below pass `?format=`
  # through when one is asked for; with none, the render host's default (jpeg)
  # applies.
  FORMATS = %w[png jpeg webp pdf].freeze
 
  # 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.
  SIZES = { "og" => nil, "story" => ENV.fetch("IMEJIS_VARIATION_ID", "story") }.freeze
 
  def og_size
    size = params[:size] || "og"
    return head :not_found unless SIZES.key?(size)
 
    query = {}
    query["variation"] = SIZES[size] if SIZES[size]
    # request.query_parameters, not params: Rails reads params[:format] as the
    # RESPONSE format (see #show above).
    requested = request.query_parameters["format"]
    query["format"] = requested if FORMATS.include?(requested)
    quality = request.query_parameters["quality"].to_i
    query["quality"] = quality if quality.between?(1, 100)
 
    uri = URI("#{BASE}/v1/#{ENV['IMEJIS_DESIGN_ID']}")
    uri.query = URI.encode_www_form(query)
    upstream = Net::HTTP.post(uri, {
      "headline.text" => params[:title] || "Every size"
    }.to_json, HEADERS)
    return head :bad_gateway unless upstream.is_a?(Net::HTTPSuccess)
 
    headers["Cache-Control"] = "public, immutable, no-transform, max-age=31536000"
    send_data upstream.body,
              type: upstream["content-type"] || "image/jpeg",
              disposition: "inline"
  end
end

require "json"
require "net/http"
 
class OgController < ApplicationController
  BASE = ENV.fetch("IMEJIS_RENDER_URL", "https://render.imejis.io")
  HEADERS = {
    "dma-api-key" => ENV["IMEJIS_API_KEY"],
    "Content-Type" => "application/json"
  }.freeze
 
  # The formats the render API accepts. The actions below pass `?format=`
  # through when one is asked for; with none, the render host's default (jpeg)
  # applies.
  FORMATS = %w[png jpeg webp pdf].freeze
 
  # Ask for a stored URL instead of bytes. `hosted` is public and permanent;
  # `signed` is private and expires (`expiresIn` is minutes).
  #
  # Not `og_url`: routing `get "og"` generates an `og_url` helper, and Rails
  # treats a method that shadows a helper as internal rather than as an action
  # — the request 404s with "the action could not be found".
  def stored_url
    delivery = params[:private] ? "signed" : "hosted"
    query = { "delivery" => 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.
    requested = request.query_parameters["format"]
    query["format"] = requested if FORMATS.include?(requested)
    query["expiresIn"] = 30 if delivery == "signed"
 
    uri = URI("#{BASE}/v1/#{ENV['IMEJIS_DESIGN_ID']}")
    uri.query = URI.encode_www_form(query)
    upstream = Net::HTTP.post(uri, {
      "headline.text" => params[:title] || "Shared card"
    }.to_json, HEADERS)
 
    # { url, format, file: { size }, expiresAt (signed only) }
    stored = JSON.parse(upstream.body)
    render json: {
      url: stored["url"],
      format: stored["format"],
      expiresAt: stored["expiresAt"]
    }
  end
end

require "json"
require "net/http"
 
class OgController < ApplicationController
  BASE = ENV.fetch("IMEJIS_RENDER_URL", "https://render.imejis.io")
  HEADERS = {
    "dma-api-key" => ENV["IMEJIS_API_KEY"],
    "Content-Type" => "application/json"
  }.freeze
 
  # The formats the render API accepts. The actions below pass `?format=`
  # through when one is asked for; with none, the render host's default (jpeg)
  # applies.
  FORMATS = %w[png jpeg webp pdf].freeze
 
  # One POST renders many images and returns a URL for each, in the order sent
  # — a row per record, or one per size.
  def og_bulk
    rows = params[:rows] || []
    upstream = Net::HTTP.post(URI("#{BASE}/bulk"), {
      "designId" => ENV["IMEJIS_DESIGN_ID"],
      "delivery" => "hosted",
      "format" => "png",
      "data" => rows.map do |row|
        { "headline.text" => row[:name], "subtitle.text" => row[:role].to_s }
      end
    }.to_json, HEADERS)
 
    bulk = JSON.parse(upstream.body)
    render json: {
      summary: bulk["summary"],
      urls: bulk["results"].map { |result| result["url"] }
    }
  end
end

<%#
  og:image points at YOUR OWN action, so crawlers fetch your domain and get an
  absolute URL they can follow. In a real layout this is where the per-record
  title goes: og_url(title: @post.title).
%>
<head>
  <meta property="og:image" content="<%= @og_image %>">
  <meta name="twitter:card" content="summary_large_image">
</head>
 
<%#
  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 markup, so it has to be one you
  are happy to expose. Keep the proxy whenever it must stay private: that is
  the right default, and what the show action above is for.
%>
<img src="<%= @direct %>" width="1200" height="630" alt="Card for <%= @title %>">