camox 0.75.0 → 0.76.1

package/dist/features/runtime/reader.js

@@ -0,0 +1,142 @@
+import { draftNamedBy } from "../../lib/draft-scope.js";
+import { buildClearServerAuthCookieHeader, getLookToken, getServerAuthCookieHeader } from "../../lib/server-auth-cookie.js";
+import { createServerApiClient, draftRefusalNotice, isAuthSessionError } from "../routes/pageRuntime.js";
+import { DRAFT_SEARCH_PARAM } from "@camox/api-contract/drafts";
+
+//#region src/features/runtime/reader.ts
+/** The content port's production adapter: the API at `apiUrl`, over oRPC. */
+function apiContent(apiUrl) {
+	return (access) => createServerApiClient(apiUrl, access);
+}
+function contentOf(options) {
+	return options.content ?? (options.apiUrl ? apiContent(options.apiUrl) : void 0);
+}
+/**
+* Whether a request may see what only it sees, so no shared cache keeps its response (ADR 0022).
+* Known before any read, so a cache can decide before the runtime answers.
+*/
+function isPrivateRequest(request) {
+	return !!getServerAuthCookieHeader(request.headers) || draftNamedBy(request.url) !== null;
+}
+/**
+* The request's Reader: a Member when the API confirms its session for the project, which it
+* asks once, else a Visitor. A session the API refuses is cleared. Without a project or a way to
+* read content, nobody is a Member.
+*/
+async function resolveReader(request, options) {
+	const content = contentOf(options);
+	const session = getServerAuthCookieHeader(request.headers);
+	const named = draftNamedBy(request.url) ?? void 0;
+	const isPrivate = isPrivateRequest(request);
+	if (!content || !options.projectUuid || !session) return visitor(content, options, {
+		named,
+		private: isPrivate
+	});
+	let member;
+	try {
+		member = await content({ credential: { session } }).projects.getByUuid({ projectUuid: options.projectUuid });
+	} catch (error) {
+		if (!isAuthSessionError(error)) throw error;
+		console.warn("[camox] Ignoring stale camox_auth_cookie.");
+		return visitor(content, options, {
+			named,
+			private: isPrivate,
+			setCookie: buildClearServerAuthCookieHeader()
+		});
+	}
+	const credential = { session };
+	const api = ({ draftId, locale } = {}) => content({
+		credential,
+		draftId,
+		locale
+	});
+	return withLocales(options, {
+		member,
+		draftId: named,
+		private: isPrivate,
+		setCookie: void 0,
+		api,
+		read: async (read) => {
+			if (!named) return { value: await read(void 0) };
+			try {
+				return {
+					value: await read(named),
+					draftId: named
+				};
+			} catch (error) {
+				const notice = draftRefusalNotice(error, named);
+				if (notice === void 0) throw error;
+				return {
+					value: await read(void 0),
+					refusedDraft: { notice }
+				};
+			}
+		}
+	});
+}
+/**
+* A Visitor's Reader, for what reads Live whoever asks (sitemaps, llms.txt, Markdown): no
+* session check, no credential.
+*/
+function visitorReader(options) {
+	return visitor(contentOf(options), options, {
+		named: void 0,
+		private: false
+	});
+}
+/**
+* The look document's Reader (ADR 0032): the look token the request's cookie carries, for the
+* Draft the URL names. Null without both.
+*/
+function lookReader(request, options) {
+	const content = contentOf(options);
+	const lookToken = getLookToken(request.headers);
+	const draftId = new URL(request.url).searchParams.get(DRAFT_SEARCH_PARAM) || void 0;
+	if (!content || !lookToken || !draftId) return null;
+	const credential = { lookToken };
+	return withLocales(options, {
+		member: void 0,
+		draftId,
+		private: true,
+		setCookie: void 0,
+		api: ({ locale } = {}) => content({
+			credential,
+			draftId,
+			locale
+		}),
+		read: async (read) => ({
+			value: await read(draftId),
+			draftId
+		})
+	});
+}
+function visitor(content, options, { named, private: isPrivate, setCookie }) {
+	const api = ({ locale } = {}) => {
+		if (!content) throw new Error("Camox has no content to read: the runtime names no API.");
+		return content({ locale });
+	};
+	return withLocales(options, {
+		member: void 0,
+		draftId: void 0,
+		private: isPrivate,
+		setCookie,
+		api,
+		read: async (read) => ({
+			value: await read(void 0),
+			...named && { refusedDraft: { notice: null } }
+		})
+	});
+}
+function withLocales(options, reader) {
+	return {
+		...reader,
+		locales: async () => {
+			const projectUuid = options.projectUuid;
+			const { value } = await reader.read((draftId) => reader.api({ draftId }).locales.list({ projectUuid }));
+			return value;
+		}
+	};
+}
+
+//#endregion
+export { apiContent, isPrivateRequest, lookReader, resolveReader, visitorReader };

package/dist/features/runtime/runtime.d.ts

@@ -3,9 +3,10 @@ import { AlternatePath, LocaleView } from "../../lib/locale-path.js";
 import { AnyLayoutLoaderResult } from "../../core/createLayout.js";
 import { CamoxApp } from "../../core/createApp.js";
 import { AnalyticsProviders } from "./analytics.js";
+import { Content, ContentClient } from "./reader.js";
 import { RuntimeOwnedRouteKind } from "./runtimeRoutes.js";
 import { StudioRenderInput } from "./studioApp.js";
-import { DraftRead, MemberProject, PageHead, createServerApiClient } from "../routes/pageRuntime.js";
+import { DraftRead, MemberProject, PageHead } from "../routes/pageRuntime.js";
 import { LookPlaceholderHeight } from "@camox/api-contract/drafts";
 import { UseHeadInput } from "unhead/types";
 //#region src/features/runtime/runtime.d.ts
@@ -47,7 +48,7 @@ export interface PageRenderInput extends DraftRead {
    */
   lookLayout?: {
     layoutId: string;
-    layout: Awaited<ReturnType<ReturnType<typeof createServerApiClient>["layouts"]["getUnplaced"]>>["layout"];
+    layout: Awaited<ReturnType<ContentClient["layouts"]["getUnplaced"]>>["layout"];
     placeholder: LookPlaceholderHeight;
     path: string;
     projectName: string;
@@ -74,7 +75,7 @@ export interface PageRenderInput extends DraftRead {
       projectName: string;
     };
     result?: AnyLayoutLoaderResult;
-    layout: Awaited<ReturnType<ReturnType<typeof createServerApiClient>["layouts"]["get"]>>["layout"];
+    layout: Awaited<ReturnType<ContentClient["layouts"]["get"]>>["layout"];
   };
   apiUrl: string;
   authenticationUrl: string;
@@ -97,6 +98,11 @@ export interface PageRenderInput extends DraftRead {
 }
 export interface RuntimeOptions {
   apiUrl?: string;
+  /**
+   * Where the runtime reads content, as each request's Reader sees it. Without it, the API at
+   * `apiUrl`. Tests read an in-memory one.
+   */
+  content?: Content;
   authenticationUrl?: string;
   /** Where the browser loads each block from, so a page can preload the blocks it renders. */
   blockPreloads?: {