@synqauth/nextjs 0.0.0-stage → 0.2.0

package/dist/proxy.d.ts

@@ -0,0 +1,28 @@
+import { t as SynqAuthOptions } from "./config-CpEbAGEs.js";
+//#region src/proxy.d.ts
+/** What `synqProxy()` takes: which paths need a session. */
+export interface SynqProxyOptions {
+  /**
+   * Paths that need someone signed in: path prefixes, or a test. There is no
+   * default: everything would send the app's images, `robots.txt` and
+   * `/.well-known/` files to sign in. Narrow what the proxy runs on with
+   * `export const config = { matcher }` as well.
+   */
+  readonly protect: readonly string[] | ((pathname: string) => boolean);
+  /**
+   * The app's own page saying why a sign-in didn't finish: a protected
+   * request without a session that came back with `synq_error` is
+   * rewritten to it, with `synq_error` and `returnTo` in its query (read
+   * them with `synqAuth().signInError()`), and it is never protected
+   * itself. Without it, the proxy answers such a request with a plain page
+   * of its own. Either way, it never sends that request to sign in again.
+   */
+  readonly signInError?: string;
+}
+/**
+ * Next's proxy for Synq: refreshes a session that is due, and sends a
+ * request to a protected path without one to sign in, or, when a sign-in
+ * just failed, to the page that says why.
+ */
+export declare function synqProxy(config: SynqAuthOptions, options: SynqProxyOptions): (request: Request) => Promise<Response | undefined>;
+//#endregion

package/dist/proxy.js

@@ -0,0 +1,59 @@
+import { a as withoutSignInError, f as resolveConfig, i as signInErrorPage, o as createSynqCore, r as signInErrorOf, t as SIGN_IN_ERROR_PARAM, u as requestJar } from "./sign-in-error-kd56GHt_.js";
+import { NextResponse } from "next/server.js";
+//#region src/proxy.ts
+/**
+* Next's proxy for Synq: refreshes a session that is due, and sends a
+* request to a protected path without one to sign in, or, when a sign-in
+* just failed, to the page that says why.
+*/
+function synqProxy(config, options) {
+	const { protect, signInError } = options;
+	if (signInError !== void 0 && !/^\/(?![/\\])/.test(signInError)) throw new TypeError("synqProxy: signInError is a path on the app, such as /sign-in-error");
+	const protectsPath = typeof protect === "function" ? protect : (path) => protect.some((prefix) => under(path, prefix));
+	const protects = (path) => !(signInError !== void 0 && under(path, signInError)) && protectsPath(path);
+	let core;
+	return async function proxy(request) {
+		core ??= createSynqCore(resolveConfig(config));
+		const url = new URL(request.url);
+		if (under(url.pathname, core.config.basePath)) return void 0;
+		const jar = requestJar(request);
+		const signedIn = await core.refreshIfDue(jar);
+		const changes = jar.headers();
+		if (!signedIn && protects(url.pathname)) {
+			const returnTo = withoutSignInError(`${url.pathname}${url.search}`);
+			const failed = signInErrorOf(url.searchParams.get(SIGN_IN_ERROR_PARAM), core.config.basePath, returnTo);
+			if (failed) {
+				const response = signInError ? NextResponse.rewrite(errorPageUrl(signInError, url, failed.code, returnTo)) : signInErrorPage(failed);
+				for (const cookie of changes) response.headers.append("set-cookie", cookie);
+				return response;
+			}
+			const signIn = new URL(`${core.config.basePath}/sign-in`, core.config.appUrl);
+			signIn.searchParams.set("returnTo", returnTo);
+			const response = new Response(null, {
+				status: 307,
+				headers: { location: signIn.href }
+			});
+			for (const cookie of changes) response.headers.append("set-cookie", cookie);
+			return response;
+		}
+		if (changes.length === 0) return void 0;
+		const headers = new Headers(request.headers);
+		headers.set("cookie", jar.cookieHeader());
+		const response = NextResponse.next({ request: { headers } });
+		for (const cookie of changes) response.headers.append("set-cookie", cookie);
+		return response;
+	};
+}
+/** The app's page for a sign-in error, with the error and where its ways on come back to. */
+function errorPageUrl(path, url, code, returnTo) {
+	const page = new URL(path, url);
+	page.searchParams.set(SIGN_IN_ERROR_PARAM, code);
+	page.searchParams.set("returnTo", returnTo);
+	return page;
+}
+function under(path, prefix) {
+	const base = prefix.replace(/\/+$/, "");
+	return base === "" || path === base || path.startsWith(`${base}/`);
+}
+//#endregion
+export { synqProxy };