TL;DR — A CMS admin's GitHub OAuth sign-in exchanges the authorization code for a token server-side, parsing GitHub's response through a schema validator. On failure, GitHub's token endpoint returns a specific, useful error (e.g. bad_verification_code, incorrect_client_credentials) — but the schema didn't account for that error shape, so every failure just logged a generic Zod validation error instead of GitHub's actual reason.
A GitHub sign-in attempt fails, and the only thing in the server logs is a schema-mismatch stack trace — nothing that says why the OAuth exchange itself failed.
Root cause
GitHub's token endpoint doesn't always return the success-shaped JSON body the code expected; on failure it returns a differently-shaped error body. Feeding that straight into a strict success schema throws a generic validation error about the schema mismatch, which discards the actual, specific reason GitHub gave.
// throw the raw response body instead of letting schema validation
// swallow it
if (!response.ok) {
const body = await response.text();
throw new OAuthError("github_token_exchange_failed: " + body);
}
emdashkits.com
Lessons learned
When wrapping any third-party API response in a schema validator, explicitly handle the documented error shape — don't let a generic parse failure be the only thing that surfaces.
A vague validation error in the logs, right after a third-party API call, is a signal to check whether the real response body is being discarded before you ever see it.
TL;DR — A custom session-cookie login flow appeared to succeed on localhost (the OTP verified, the response looked fine) but every subsequent request to a login-gated page treated the visitor as logged out. Identical code worked fine on the live HTTPS site. The cookie's Secure attribute was hardcoded to true — and per the cookie spec, browsers never store or send a Secure cookie over a plain, non-HTTPS connection.
Check the actual Set-Cookie response header and the browser's own cookie storage panel — on localhost over http://, the cookie is sent by the server but never actually stored by the browser.
Root cause
// before -- assumes the app is always served over HTTPS
setCookie("session", token, { secure: true, httpOnly: true });
emdashkits.com
A cookie config that quietly assumes "we're always on HTTPS" breaks the instant you test over plain HTTP, which local dev servers commonly are.
// after -- derive secure from the actual request protocol
const isHttps = request.url.startsWith("https://");
setCookie("session", token, { secure: isHttps, httpOnly: true });
emdashkits.com
Lessons learned
Any Secure-flagged cookie needs to key off the real request scheme, not an assumption baked in once at cookie-creation time.
"Works in production, silently fails in local dev" is a strong signal to check cookie flags before anything else in an auth flow.
Check other cookies in the same codebase for the same hardcoded assumption — if one cookie has this bug, sibling cookies set the same way are worth auditing too.
TL;DR — GA4's gtag.js snippet was installed correctly, the page loaded with no visible JavaScript error, and GA4's real-time report still showed zero activity. The CMS's default Content-Security-Policy had no allowance for analytics domains and no config option to add one — so every request to Google's tracking endpoints was blocked at the browser level before it could fail loudly.
Check the browser's dedicated CSP violation reporting, not the regular console error list — CSP blocks are reported through their own channel, not thrown as normal script errors, so "no console errors" doesn't mean nothing was blocked.
Root cause
The CSP's script-src and connect-src directives had no entry for googletagmanager.com or google-analytics.com, and the CMS exposed no configuration surface to add one — the only way in was patching the CSP directives directly.
// patch-package: add analytics domains to the existing CSP directives
scriptSrc.push("https://www.googletagmanager.com");
connectSrc.push("https://www.google-analytics.com", "https://www.googletagmanager.com");
"No console errors" is not proof nothing was blocked — CSP violations live in their own reporting surface and are easy to miss if you're only scanning for red error text.
Before adding any third-party script tag to a site with a CSP already in place, check the CSP's directives first rather than assuming a silently-empty analytics dashboard means a snippet-installation mistake.
Comments