Node.js

npm init -y
npm pkg set type=module
npm install usethatapp

UTA_CLIENT_ID=...            # required
UTA_CLIENT_SECRET=...        # required (server-side only)
UTA_REDIRECT_URI=http://localhost:3000/callback
# optional — default to production:
UTA_ISSUER=https://www.usethatapp.com/o
UTA_API_URL=https://www.usethatapp.com
UTA_SCOPES="openid entitlements"

import { createServer } from "node:http";
import { randomBytes } from "node:crypto";

import { beginLogin, completeLogin, getEntitlement, logoutUrl, UtaError, UtaTokenError } from "usethatapp";

// Toy server-side session store keyed by a cookie. Use a real session in prod.
const sessions = new Map();

function getSession(req, res) {
  const sid = (req.headers.cookie ?? "").match(/sid=([^;]+)/)?.[1];
  if (sid && sessions.has(sid)) return sessions.get(sid);
  const id = randomBytes(16).toString("hex");
  const data = {};
  sessions.set(id, data);
  res.setHeader("Set-Cookie", `sid=${id}; HttpOnly; Path=/`);
  return data;
}

export function createApp() {
  return createServer(async (req, res) => {
    const url = new URL(req.url, "http://localhost");
    const sess = getSession(req, res);
    try {
      if (url.pathname === "/login") {
        const { authorizationUrl, flowState } = await beginLogin();
        sess.utaFlow = flowState;
        res.writeHead(302, { Location: authorizationUrl }).end();
      } else if (url.pathname === "/callback") {
        // On cancel/deny, OAuth redirects back with ?error=... and no code.
        if (url.searchParams.get("error")) {
          delete sess.utaFlow;
          res.writeHead(302, { Location: "/" }).end();
          return;
        }
        const s = await completeLogin({
          code: url.searchParams.get("code"),
          state: url.searchParams.get("state"),
          flowState: sess.utaFlow,
        });
        delete sess.utaFlow;
        sess.utaSub = s.sub;
        sess.utaAccessToken = s.access_token;
        sess.utaIdToken = s.id_token;
        res.writeHead(302, { Location: "/" }).end();
      } else if (url.pathname === "/logout") {
        // Don't clear the session yet — the user may choose "Stay signed in". A
        // real logout revokes the token, so the next getEntitlement (home) 401s
        // and we drop it then.
        const idToken = sess.utaIdToken;
        res.writeHead(302, { Location: await logoutUrl({ idToken }) }).end();
      } else {
        if (sess.utaAccessToken) {
          try {
            const ent = await getEntitlement(sess.utaAccessToken);
            res.setHeader("Content-Type", "application/json");
            res.end(JSON.stringify({ sub: sess.utaSub, entitlement: ent.raw }));
            return;
          } catch (e) {
            if (!(e instanceof UtaTokenError)) throw e;
            // Token revoked/expired (signed out of UseThatApp). Reconcile.
            delete sess.utaAccessToken; delete sess.utaSub; delete sess.utaIdToken;
          }
        }
        res.end('<a href="/login">Log in with UseThatApp</a>');
      }
    } catch (e) {
      res.writeHead(e instanceof UtaError ? 400 : 500).end(`error: ${e.message}`);
    }
  });
}

if (import.meta.url === `file://${process.argv[1]}`) {
  const port = Number(process.env.PORT ?? 3000);
  createApp().listen(port, () => {
    console.log(`node-http-min listening on http://127.0.0.1:${port}`);
  });
}

import { getEntitlement, UtaTokenError, UtaPermissionError } from "usethatapp";

const PRO_PRODUCT_ID = process.env.PRO_PRODUCT_ID; // stable prod_... product id

export async function isPro(accessToken) {
  try {
    const ent = await getEntitlement(accessToken);
    return ent.entitled && ent.product_public_id === PRO_PRODUCT_ID;
  } catch (e) {
    if (e instanceof UtaTokenError) return null;        // re-authenticate
    if (e instanceof UtaPermissionError) return false;  // missing entitlements scope
    throw e;
  }
}

import { getEntitlement, manageUrl, purchaseUrl } from "usethatapp";

const PRO_PRODUCT_ID = process.env.PRO_PRODUCT_ID; // stable prod_... product id
const PRO_PRICE_ID = process.env.PRO_PRICE_ID;     // prc_... — from getPrices() or your dashboard

// Inside createApp()'s request handler, next to the other branches:
if (url.pathname === "/account") {
  const ent = await getEntitlement(sess.utaAccessToken);
  res.setHeader("Content-Type", "application/json");
  if (ent.entitled && ent.product_public_id === PRO_PRODUCT_ID) {
    // Already on Pro — link to the hosted subscription-management page.
    res.end(JSON.stringify({ plan: ent.version, manage: manageUrl({ next: "http://localhost:3000/account" }) }));
  } else {
    // Not on Pro — hosted checkout. They return signed in, entitled.
    res.end(JSON.stringify({ plan: ent.version, upgrade: purchaseUrl(PRO_PRICE_ID, { next: "http://localhost:3000/account" }) }));
  }
}