@redeemid/emdash 0.0.2 → 0.0.3

package/README.md

@@ -2,7 +2,7 @@
 
 Shopify customer accounts, member levels and paywalls for [EmDash](https://github.com/emdash-cms/emdash) sites. Shopify runs the store and the customer account; EmDash runs the content.
 
-**Status: 0.0.2, early.** Runs on Node and Cloudflare Workers. Sign-in, the member mirror, webhooks, levels, rules, the page gate and plan checkout are covered by an end-to-end test against a fake store.
+**Status: 0.0.3, early.** Runs on Node and Cloudflare Workers. Sign-in, the member mirror, webhooks, levels, rules, the page gate, the Shopify cart and checkout are covered by an end-to-end test against a fake store.
 
 ## What it does
 
@@ -10,8 +10,11 @@ Shopify customer accounts, member levels and paywalls for [EmDash](https://githu
 - **Mirrors the customer.** Email, name, tags and enabled/disabled status, kept current by signed Shopify webhooks.
 - **Levels from tags.** You map Shopify customer tags to levels. Set tags in Shopify Flow or any app; RedeemID only reads them.
 - **Rules per collection or term.** Lock a collection, or only entries in a category or tag.
-- **Plans and checkout.** `<Plan>` shows a Shopify product's price and starts checkout through the Storefront API.
-- **A page gate.** `<Gate>` shows the entry to readers who may read it and a teaser plus "Sign in" to everyone else.
+- **Plans, cart and checkout.** `<Plan>` shows a Shopify product's price and adds it to the visitor's Shopify cart; `<Cart>` shows the count and opens Shopify checkout.
+- **Account.** Members get an Account link to their Shopify customer account (orders, profile, addresses) and Sign out, which also ends the Shopify session.
+- **Paywall break block.** Editors write one body and drop a "Paywall break" block where members-only content starts, picking which levels may read on. `<Content>` renders the body and leaves the rest off the page for everyone else.
+- **Plan block.** Editors add a Shopify product to any page with the "Plan" block: title, price and a buy button.
+- **In the admin.** RedeemID shows under Plugins with a Members page (Shopify customers, tags, levels), a Status page (secrets, store discovery, the URLs to give Shopify, levels and rules) and a dashboard widget.
 - **Keeps members out of EmDash's own APIs**, so the gate is the only way to read locked content.
 
 ## Install
@@ -23,28 +26,29 @@ pnpm add @redeemid/emdash
 ```
 
 ```js title="astro.config.mjs"
-import { redeemid, redeemidGuard } from "@redeemid/emdash";
+import { redeemid, redeemidGuard, redeemidPlugin } from "@redeemid/emdash";
 import emdash from "emdash/astro";
 
+const config = {
+	shop: "my-store.myshopify.com",
+	levels: [
+		{ slug: "member", name: "Member", tags: ["member"] },
+		{ slug: "pro", name: "Pro", tags: ["pro"] },
+		// match: "all" needs every tag, e.g. both memberships:
+		{ slug: "both", name: "Member + Pro", tags: ["member", "pro"], match: "all" },
+	],
+	rules: [
+		{ collection: "posts", taxonomy: "category", term: "members", levels: ["member", "pro"] },
+		{ collection: "posts", taxonomy: "category", term: "pro", levels: ["pro"] },
+	],
+};
+
 export default defineConfig({
 	integrations: [
 		emdash({
 			// database, storage, …
-			authProviders: [
-				redeemid({
-					shop: "my-store.myshopify.com",
-					levels: [
-						{ slug: "member", name: "Member", tags: ["member"] },
-						{ slug: "pro", name: "Pro", tags: ["pro"] },
-						// match: "all" needs every tag, e.g. both memberships:
-						{ slug: "both", name: "Member + Pro", tags: ["member", "pro"], match: "all" },
-					],
-					rules: [
-						{ collection: "posts", taxonomy: "category", term: "members", levels: ["member", "pro"] },
-						{ collection: "posts", taxonomy: "category", term: "pro", levels: ["pro"] },
-					],
-				}),
-			],
+			authProviders: [redeemid(config)], // sign-in, webhooks, cart and checkout routes
+			plugins: [redeemidPlugin(config)], // admin pages and the editor blocks
 		}),
 		redeemidGuard(),
 	],
@@ -74,28 +78,33 @@ Point webhooks (`customers/create`, `customers/update`, `customers/delete`, `cus
 
 ## Use it in templates
 
-EmDash has no content filter hook, so templates decide what to render. Wrap the entry body:
+EmDash has no content filter hook, so templates decide what to render. Render the entry body with `<Content>` instead of `<PortableText>`:
 
 ```astro
 ---
-import Gate from "@redeemid/emdash/components/Gate.astro";
+import Content from "@redeemid/emdash/components/Content.astro";
 ---
-<Gate collection="posts" terms={post.data.terms}>
-	<PortableText value={post.data.content} />
-	<p slot="locked">{post.data.excerpt}</p>
-</Gate>
+<Content value={post.data.content} collection="posts" terms={post.data.terms}>
+	<a slot="locked" href="/join/">Become a member</a>
+</Content>
 ```
 
-Add the account box to your header:
+Everything before the first Paywall break block is shown to everyone. What follows reaches the page only for readers the break allows: the levels picked on it, or when none are picked the entry's rule, or else any signed-in member. A body with no break follows the entry's rule as a whole. Plain `<PortableText>` ignores the break and shows everything, so use `<Content>` for any body that may hold one.
+
+To lock a part of a template that isn't the body, wrap it in `<Gate>` (`<Gate levels={["pro"]}>…</Gate>`).
+
+Add the account box and cart to your header. Visitors see Sign in; members see their name, levels, Account and Sign out. The cart shows how many items are in the visitor's Shopify cart and goes to its checkout:
 
 ```astro
 ---
 import Account from "@redeemid/emdash/components/Account.astro";
+import Cart from "@redeemid/emdash/components/Cart.astro";
 ---
 <Account />
+<Cart />
 ```
 
-Sell a plan. `<Plan>` shows a Shopify product's title and price with a button that starts checkout (signed-in members check out with their email). Shopify Flow or an app tags the customer after the order, and access follows that tag:
+Sell a plan. `<Plan>` shows a Shopify product's title and price with a button that adds it to the visitor's Shopify cart and opens checkout (signed-in members check out with their email). Shopify Flow or an app tags the customer after the order, and access follows that tag:
 
 ```astro
 ---

package/docs/shopify-setup.md

@@ -53,4 +53,4 @@ The Workers free plan is enough: RedeemID is a native plugin and doesn't need sa
 3. Click **Sign in**, sign in with that customer's email, and you come back to the post, unlocked.
 4. Add or remove the tag in Shopify; the post opens or locks again once the webhook arrives.
 
-If sign-in sends you back with `?redeemid_notice=…`, the code says why: `not_configured` (secrets or `shop` missing), `sign_in_unavailable` (store discovery failed), `sign_in_expired`, `staff_account`, `site_not_ready`, `email_required`, `token_failed`, `bad_id_token`, `identity_failed`. A Buy button can return `plan_unavailable` (no such product, or sold out) or `checkout_failed`.
+If sign-in sends you back with `?redeemid_notice=…`, the code says why: `not_configured` (secrets or `shop` missing), `sign_in_unavailable` (store discovery failed), `sign_in_expired`, `staff_account`, `site_not_ready`, `email_required`, `token_failed`, `bad_id_token`, `identity_failed`. A Buy button can return `plan_unavailable` (no such product, or sold out) or `checkout_failed`. The Cart link returns `cart_empty` when there's nothing in the cart, and Account returns `account_unavailable` when store discovery fails.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@redeemid/emdash",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"description": "Shopify customer accounts, member levels and paywalls for EmDash sites. Shopify runs commerce; EmDash runs content.",
 	"type": "module",
 	"license": "MIT",
@@ -15,6 +15,8 @@
 		"./access": "./src/access.ts",
 		"./guard.ts": "./src/guard.ts",
 		"./storefront": "./src/storefront.ts",
+		"./plugin": "./src/plugin.ts",
+		"./blocks": "./src/blocks/index.ts",
 		"./components/*": "./src/components/*",
 		"./routes/*": "./src/routes/*"
 	},

package/src/access.ts

@@ -119,6 +119,16 @@ export function signInUrl(returnTo: string): string {
 	return `/_emdash/api/auth/redeemid/login?return=${encodeURIComponent(safeReturn(returnTo))}`;
 }
 
+/** Where the Cart link goes: the visitor's Shopify checkout. */
+export function cartUrl(returnTo = "/"): string {
+	return `/_emdash/api/auth/redeemid/cart?return=${encodeURIComponent(safeReturn(returnTo))}`;
+}
+
+/** Where the Account link goes: the member's Shopify customer account. */
+export function accountUrl(returnTo = "/"): string {
+	return `/_emdash/api/auth/redeemid/account?return=${encodeURIComponent(safeReturn(returnTo))}`;
+}
+
 export function signOutUrl(returnTo = "/"): string {
 	return `/_emdash/api/auth/redeemid/logout?return=${encodeURIComponent(safeReturn(returnTo))}`;
 }

package/src/astro-modules.d.ts

@@ -0,0 +1,4 @@
+declare module "*.astro" {
+	const Component: (props: Record<string, unknown>) => unknown;
+	export default Component;
+}

package/src/blocks/PaywallBreak.astro

@@ -0,0 +1,6 @@
+---
+/**
+ * The paywall break itself renders nothing. <Content> splits the body here
+ * and leaves out what follows for readers who can't read it.
+ */
+---

package/src/blocks/PlanBlock.astro

@@ -0,0 +1,13 @@
+---
+/** The "Plan" block: a Shopify product with its price and a buy button. */
+import Plan from "../components/Plan.astro";
+
+interface Props {
+	node: { handle?: string; title?: string; label?: string };
+}
+
+const { node } = Astro.props;
+const handle = (node.handle ?? "").trim();
+---
+
+{handle && <Plan handle={handle} title={node.title?.trim() || undefined} label={node.label?.trim() || "Join"} />}

package/src/blocks/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Site-side renderers for RedeemID's Portable Text blocks, picked up by
+ * EmDash from the plugin's `componentsEntry`.
+ */
+import PaywallBreak from "./PaywallBreak.astro";
+import PlanBlock from "./PlanBlock.astro";
+
+export const blockComponents = {
+	"redeemid-paywall": PaywallBreak,
+	"redeemid-plan": PlanBlock,
+};

package/src/blocks-names.ts

@@ -0,0 +1,24 @@
+/** Portable Text block types RedeemID adds to the editor. */
+export const PAYWALL_BLOCK = "redeemid-paywall";
+export const PLAN_BLOCK = "redeemid-plan";
+
+type Node = { _type?: unknown; levels?: unknown };
+
+/**
+ * Split a Portable Text body at its first paywall break: the open part, the
+ * members part, and the levels picked on the break (empty = none picked).
+ * With no break, everything is in `open` and `paywall` is false.
+ */
+export function splitAtPaywall<T>(value: T[] | null | undefined): {
+	open: T[];
+	locked: T[];
+	levels: string[];
+	paywall: boolean;
+} {
+	const blocks = Array.isArray(value) ? value : [];
+	const at = blocks.findIndex((b) => (b as Node)?._type === PAYWALL_BLOCK);
+	if (at === -1) return { open: blocks, locked: [], levels: [], paywall: false };
+	const raw = (blocks[at] as Node).levels;
+	const levels = Array.isArray(raw) ? raw.filter((l): l is string => typeof l === "string" && l !== "") : [];
+	return { open: blocks.slice(0, at), locked: blocks.slice(at + 1), levels, paywall: true };
+}

package/src/cart.ts

@@ -0,0 +1,25 @@
+/**
+ * The visitor's Shopify cart, kept in the Astro session. Only the cart id
+ * and its item count live here; Shopify holds the lines and the checkout.
+ */
+
+export const SESSION_CART = "redeemid:cart";
+
+export interface CartRef {
+	id: string;
+	count: number;
+}
+
+type Session = { get(key: string): unknown; set(key: string, value: unknown): void; delete?(key: string): void } | undefined;
+
+export async function readCart(session: Session): Promise<CartRef | null> {
+	const v = (await session?.get(SESSION_CART)) as CartRef | undefined;
+	return v && typeof v.id === "string" ? v : null;
+}
+
+export function saveCart(session: Session, cart: CartRef | null): void {
+	if (!session) return;
+	if (cart) session.set(SESSION_CART, cart);
+	else if (session.delete) session.delete(SESSION_CART);
+	else session.set(SESSION_CART, undefined);
+}

package/src/components/Account.astro

@@ -1,9 +1,9 @@
 ---
 /**
- * Sign in link for visitors; name, levels and Sign out for members.
+ * Sign in link for visitors; name, levels, Account and Sign out for members.
  */
 import { siteConfig } from "../site-config.js";
-import { signInUrl, signOutUrl, viewer } from "../access.js";
+import { accountUrl, signInUrl, signOutUrl, viewer } from "../access.js";
 
 const v = await viewer(Astro);
 const config = siteConfig((Astro.locals as { emdash?: { config?: unknown } }).emdash?.config);
@@ -16,6 +16,7 @@ const names = (config?.levels ?? []).filter((l) => v.levels.includes(l.slug)).ma
 		<>
 			<span class="redeemid-account__who">{v.member?.firstName ?? v.member?.email ?? "Signed in"}</span>
 			{names.length > 0 && <span class="redeemid-account__levels">{names.join(", ")}</span>}
+			<a class="redeemid-account__link" href={accountUrl(here)}>Account</a>
 			<form method="post" action={signOutUrl(here)}>
 				<button type="submit">Sign out</button>
 			</form>

package/src/components/Cart.astro

@@ -0,0 +1,21 @@
+---
+/**
+ * Cart link with the item count from the visitor's Shopify cart. It goes
+ * to that cart's Shopify checkout.
+ */
+import { cartUrl } from "../access.js";
+import { readCart } from "../cart.js";
+
+interface Props {
+	label?: string;
+}
+
+const { label = "Cart" } = Astro.props;
+const ref = await readCart(Astro.session);
+const count = ref?.count ?? 0;
+const here = Astro.url.pathname + Astro.url.search;
+---
+
+<a class="redeemid-cart" href={cartUrl(here)} data-redeemid-cart-count={count}>
+	{label}{count > 0 && <span class="redeemid-cart__count"> ({count})</span>}
+</a>

package/src/components/Content.astro

@@ -0,0 +1,53 @@
+---
+/**
+ * An entry's body, with RedeemID's paywall break applied.
+ *
+ *   <Content value={post.data.content} collection="posts" terms={post.data.terms} />
+ *
+ * Everything before the first "Paywall break" block is shown to everyone.
+ * What follows reaches the page only for readers who may read it: the levels
+ * picked on the break, or when none are picked the entry's rule, or else any
+ * signed-in member. Others get the "locked" slot (or a built-in notice).
+ * A body with no break follows the entry's rule as a whole.
+ */
+import { PortableText } from "emdash/ui";
+
+import { canRead, requiredLevels, signInUrl, type Terms } from "../access.js";
+import { splitAtPaywall } from "../blocks-names.js";
+import { siteConfig } from "../site-config.js";
+
+interface Props {
+	value?: unknown[] | null;
+	collection?: string;
+	terms?: Terms;
+}
+
+const { value, collection = "", terms } = Astro.props;
+const split = splitAtPaywall(value);
+const config = siteConfig((Astro.locals as { emdash?: { config?: unknown } }).emdash?.config);
+const levels = split.paywall
+	? split.levels.length
+		? split.levels
+		: (requiredLevels(config?.rules, collection, terms) ?? [])
+	: undefined;
+const verdict = await canRead(Astro, { collection, terms }, levels ? { levels } : undefined);
+const shown = split.paywall ? split.open : verdict.allowed ? split.open : [];
+const here = Astro.url.pathname + Astro.url.search;
+---
+
+{shown.length > 0 && <PortableText value={shown} />}
+{verdict.allowed ? (
+	split.locked.length > 0 && <PortableText value={split.locked} />
+) : (
+	<div class="redeemid-locked" data-redeemid-reason={verdict.reason}>
+		<slot name="locked" />
+		{verdict.reason === "sign_in" && (
+			<p>
+				This is for members. <a href={signInUrl(here)}>Sign in</a> to read on.
+			</p>
+		)}
+		{verdict.reason === "upgrade" && <p>Your membership doesn't include the rest of this yet.</p>}
+		{verdict.reason === "disabled" && <p>Your account is turned off. Contact the store for help.</p>}
+		{verdict.reason === "unconfigured" && <p>This is for members.</p>}
+	</div>
+)}

package/src/descriptor.ts

@@ -0,0 +1,29 @@
+/**
+ * The RedeemID plugin descriptor, safe to load from astro.config.mjs (no
+ * runtime imports). The plugin itself is in plugin.ts.
+ */
+
+import type { PluginDescriptor } from "emdash";
+
+import type { RedeemIDConfig } from "./config.js";
+import { VERSION } from "./version.js";
+
+export const PAGES = [
+	{ path: "/", label: "Members", icon: "users" },
+	{ path: "/status", label: "Status", icon: "pulse" },
+];
+export const WIDGETS = [{ id: "status", title: "RedeemID", size: "half" as const }];
+
+/** The descriptor for `emdash({ plugins: [...] })`. Pass the same config as `redeemid()`. */
+export function redeemidPlugin(config: RedeemIDConfig): PluginDescriptor<RedeemIDConfig> {
+	return {
+		id: "redeemid",
+		version: VERSION,
+		entrypoint: "@redeemid/emdash/plugin",
+		componentsEntry: "@redeemid/emdash/blocks",
+		options: config,
+		adminPages: PAGES,
+		adminWidgets: WIDGETS,
+	};
+}
+

package/src/index.ts

@@ -36,6 +36,7 @@ import { STORAGE_CONFIG } from "./storage.js";
 
 export type { LevelConfig, RedeemIDConfig, RuleConfig } from "./config.js";
 export type { MemberRecord } from "./storage.js";
+export { redeemidPlugin } from "./descriptor.js";
 // Page-time helpers live in "@redeemid/emdash/access": they read the site's
 // build-time config module, which astro.config.mjs can't load.
 
@@ -54,6 +55,8 @@ export function redeemid(config: RedeemIDConfig): AuthProviderDescriptor {
 			{ pattern: `${BASE}/logout`, entrypoint: "@redeemid/emdash/routes/logout.ts" },
 			{ pattern: `${BASE}/webhook`, entrypoint: "@redeemid/emdash/routes/webhook.ts" },
 			{ pattern: `${BASE}/buy`, entrypoint: "@redeemid/emdash/routes/buy.ts" },
+			{ pattern: `${BASE}/cart`, entrypoint: "@redeemid/emdash/routes/cart.ts" },
+			{ pattern: `${BASE}/account`, entrypoint: "@redeemid/emdash/routes/account.ts" },
 		],
 		publicRoutes: [`${BASE}/`],
 		storage: STORAGE_CONFIG,

package/src/plugin.ts

@@ -0,0 +1,283 @@
+/**
+ * RedeemID as an EmDash plugin: what editors and admins see.
+ *
+ *   emdash({
+ *     authProviders: [redeemid(config)],
+ *     plugins: [redeemidPlugin(config)],
+ *   })
+ *
+ * It adds two Portable Text blocks to the editor, a Members page, a Status
+ * page and a dashboard widget. Sign-in, webhooks and checkout stay on the
+ * auth provider's routes.
+ *
+ * - "Paywall break" (`redeemid-paywall`): everything after it in the body is
+ *   for members. Pick the levels that may read on; none picked means any
+ *   signed-in member, or the entry's rule when one covers it.
+ * - "Plan" (`redeemid-plan`): a Shopify product's title and price with a
+ *   button that adds it to the cart and opens checkout.
+ *
+ * Render bodies with `<Content>` (components/Content.astro), which keeps the
+ * part after a paywall break off the page for readers who can't read it.
+ */
+
+import type { ResolvedPlugin, RouteContext } from "emdash";
+import { definePlugin } from "emdash";
+
+import { levelsFor } from "./access.js";
+import { env, ENV, storeDomain, type RedeemIDConfig } from "./config.js";
+import { discover } from "./shopify.js";
+import { stores, type MemberRecord } from "./storage.js";
+import { PAGES, WIDGETS } from "./descriptor.js";
+import { VERSION } from "./version.js";
+
+import { PAYWALL_BLOCK, PLAN_BLOCK } from "./blocks-names.js";
+
+export { PAYWALL_BLOCK, PLAN_BLOCK };
+
+function blocks(config: RedeemIDConfig) {
+	const levelOptions = (config.levels ?? []).map((l) => ({ label: l.name, value: l.slug }));
+	return [
+		{
+			type: PAYWALL_BLOCK,
+			label: "Paywall break",
+			icon: "lock",
+			description: "Everything after this is for members",
+			fields: [
+				{
+					type: "checkbox" as const,
+					action_id: "levels",
+					label: "Who can read on (none = any signed-in member)",
+					options: levelOptions,
+				},
+			],
+		},
+		{
+			type: PLAN_BLOCK,
+			label: "Plan",
+			icon: "tag",
+			description: "A Shopify product with its price and a buy button",
+			placeholder: "Shopify product handle",
+			fields: [
+				{ type: "text_input" as const, action_id: "handle", label: "Shopify product handle", placeholder: "gold-membership" },
+				{ type: "text_input" as const, action_id: "title", label: "Title (optional, Shopify's title otherwise)" },
+				{ type: "text_input" as const, action_id: "label", label: "Button label", placeholder: "Join" },
+			],
+		},
+	];
+}
+
+export function createPlugin(config: RedeemIDConfig = {}): ResolvedPlugin {
+	return definePlugin({
+		id: "redeemid",
+		version: VERSION,
+		capabilities: [],
+		admin: {
+			pages: PAGES,
+			widgets: WIDGETS,
+			portableTextBlocks: blocks(config),
+		},
+		routes: {
+			admin: {
+				handler: async (ctx: RouteContext) => {
+					const i = (ctx.input ?? {}) as { type?: string; page?: string };
+					if (i.type !== "page_load") return { blocks: [] };
+					try {
+						if (i.page === "/") return await membersPage(config);
+						if (i.page === "/status") return await statusPage(config, ctx.request);
+						if (i.page === "widget:status") return await statusWidget(config);
+					} catch (e) {
+						return { blocks: [{ type: "banner", variant: "error", title: "RedeemID couldn't load this page", description: (e as Error).message }] };
+					}
+					return { blocks: [] };
+				},
+			},
+		},
+	});
+}
+
+export default createPlugin;
+
+// ---------------------------------------------------------------- pages
+
+async function memberStores() {
+	const { getDb } = await import("emdash/runtime");
+	return stores(await getDb());
+}
+
+async function allMembers(): Promise<MemberRecord[]> {
+	const s = await memberStores();
+	const out: MemberRecord[] = [];
+	let cursor: string | undefined;
+	do {
+		const page = await s.members.query({ limit: 100, cursor });
+		out.push(...page.items.map((r) => r.data));
+		cursor = page.cursor;
+	} while (cursor && out.length < 1000);
+	return out;
+}
+
+async function membersPage(config: RedeemIDConfig) {
+	const members = await allMembers();
+	const levels = config.levels ?? [];
+	const counts = levels.map((l) => ({
+		label: l.name,
+		value: String(members.filter((m) => m.status === "enabled" && levelsFor(m.tags, levels).includes(l.slug)).length),
+	}));
+	const name = (m: MemberRecord) => [m.firstName, m.lastName].filter(Boolean).join(" ") || "—";
+	const levelNames = (m: MemberRecord) => {
+		const held = levelsFor(m.tags, levels);
+		return levels.filter((l) => held.includes(l.slug)).map((l) => l.name).join(", ") || "—";
+	};
+	return {
+		blocks: [
+			{ type: "header", text: "Members" },
+			{
+				type: "context",
+				text: "Shopify customers who have signed in or that Shopify has sent. Levels come only from their Shopify tags; change tags in Shopify (or with Flow) and access follows.",
+			},
+			{
+				type: "stats",
+				items: [
+					{ label: "Members", value: String(members.length) },
+					{ label: "Turned off", value: String(members.filter((m) => m.status === "disabled").length) },
+					...counts,
+				],
+			},
+			members.length === 0
+				? { type: "context", text: "No members yet. They appear here after their first sign-in or a Shopify customer webhook." }
+				: {
+						type: "table",
+						page_action_id: "members_page",
+						columns: [
+							{ key: "name", label: "Name" },
+							{ key: "email", label: "Email" },
+							{ key: "levels", label: "Levels" },
+							{ key: "tags", label: "Shopify tags" },
+							{ key: "status", label: "Account" },
+							{ key: "synced", label: "Last synced", format: "relative_time" },
+						],
+						rows: members
+							.sort((a, b) => b.syncedAt.localeCompare(a.syncedAt))
+							.map((m) => ({
+								name: name(m),
+								email: m.email ?? "—",
+								levels: levelNames(m),
+								tags: m.tags.join(", ") || "—",
+								status: m.status === "enabled" ? "On" : "Off",
+								synced: m.syncedAt,
+							})),
+					},
+		],
+	};
+}
+
+async function checks(config: RedeemIDConfig) {
+	const domain = storeDomain(config);
+	let discovery = "Not checked";
+	if (domain) {
+		discovery = await discover(config)
+			.then((d) => `OK (${new URL(d.authorizationEndpoint).host})`)
+			.catch((e: Error) => `Failed: ${e.message}`);
+	}
+	return {
+		domain,
+		discovery,
+		clientId: Boolean(env(ENV.clientId)),
+		webhookSecret: Boolean(env(ENV.webhookSecret)),
+		storefront: env(ENV.storefrontPrivateToken) ? "Private token" : env(ENV.storefrontPublicToken) ? "Public token" : "None (tokenless)",
+	};
+}
+
+async function lastDelivery(): Promise<string | null> {
+	const s = await memberStores();
+	const { items } = await s.deliveries.query({ orderBy: { receivedAt: "desc" }, limit: 1 });
+	const d = items[0]?.data;
+	return d ? `${d.topic} at ${d.receivedAt}` : null;
+}
+
+async function statusPage(config: RedeemIDConfig, request: Request) {
+	const c = await checks(config);
+	const origin = new URL(request.url).origin;
+	const yes = (v: boolean) => (v ? "Set" : "Missing");
+	const levels = config.levels ?? [];
+	const rules = config.rules ?? [];
+	const delivery = await lastDelivery().catch(() => null);
+	return {
+		blocks: [
+			{ type: "header", text: "Status" },
+			c.discovery.startsWith("OK") && c.clientId
+				? { type: "banner", variant: "default", title: "Sign-in is ready", description: "Members can sign in with their Shopify customer account." }
+				: { type: "banner", variant: "alert", title: "Sign-in isn't ready", description: "Set the missing values below as environment secrets, then reload." },
+			{
+				type: "fields",
+				fields: [
+					{ label: "Store domain (REDEEMID_SHOPIFY_STORE_DOMAIN or shop)", value: c.domain || "Missing" },
+					{ label: "Store discovery", value: c.discovery },
+					{ label: "Customer Account API client ID", value: yes(c.clientId) },
+					{ label: "Webhook signing secret", value: yes(c.webhookSecret) },
+					{ label: "Storefront API access", value: c.storefront },
+					{ label: "Last webhook", value: delivery ?? "None received yet" },
+				],
+			},
+			{ type: "divider" },
+			{ type: "header", text: "Shopify settings" },
+			{
+				type: "fields",
+				fields: [
+					{ label: "Callback URI", value: `${origin}/_emdash/api/auth/redeemid/callback` },
+					{ label: "JavaScript origin", value: origin },
+					{ label: "Logout URI", value: `${origin}/` },
+					{ label: "Webhook URL", value: `${origin}/_emdash/api/auth/redeemid/webhook` },
+				],
+			},
+			{ type: "divider" },
+			{ type: "header", text: "Levels" },
+			{ type: "context", text: "Set in astro.config.mjs." },
+			levels.length
+				? {
+						type: "table",
+						page_action_id: "levels_page",
+						columns: [
+							{ key: "name", label: "Level" },
+							{ key: "tags", label: "Shopify tags" },
+							{ key: "match", label: "Needs" },
+						],
+						rows: levels.map((l) => ({ name: l.name, tags: l.tags.join(", "), match: l.match === "all" ? "All tags" : "Any tag" })),
+					}
+				: { type: "context", text: "No levels configured." },
+			{ type: "header", text: "Rules" },
+			rules.length
+				? {
+						type: "table",
+						page_action_id: "rules_page",
+						columns: [
+							{ key: "where", label: "Covers" },
+							{ key: "levels", label: "Who can read" },
+						],
+						rows: rules.map((r) => ({
+							where: r.taxonomy && r.term ? `${r.collection}, ${r.taxonomy}: ${r.term}` : `All ${r.collection}`,
+							levels: r.levels.length
+								? r.levels.map((s) => levels.find((l) => l.slug === s)?.name ?? s).join(" or ")
+								: "Any signed-in member",
+						})),
+					}
+				: { type: "context", text: "No rules. Entries are open unless their body has a paywall break." },
+		],
+	};
+}
+
+async function statusWidget(config: RedeemIDConfig) {
+	const c = await checks(config);
+	const members = await allMembers().catch(() => []);
+	return {
+		blocks: [
+			{
+				type: "fields",
+				fields: [
+					{ label: "Sign-in", value: c.discovery.startsWith("OK") && c.clientId ? "Ready" : "Not ready" },
+					{ label: "Members", value: String(members.length) },
+				],
+			},
+		],
+	};
+}

package/src/routes/account.ts

@@ -0,0 +1,31 @@
+/**
+ * GET /_emdash/api/auth/redeemid/account
+ *
+ * Sends a member to their Shopify customer account (orders, profile,
+ * addresses), on the store's own account domain. Visitors who aren't
+ * signed in go through sign-in first; Shopify would ask them anyway.
+ */
+
+import type { APIRoute } from "astro";
+
+import { safeReturn, signInUrl } from "../access.js";
+import { readConfig, storeDomain } from "../config.js";
+import { discover } from "../shopify.js";
+import { fail } from "./shared.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ request, locals, session, redirect }) => {
+	const returnTo = safeReturn(new URL(request.url).searchParams.get("return"));
+	const config = readConfig((locals as { emdash?: { config?: unknown } }).emdash?.config);
+	if (!config || !storeDomain(config)) return fail(redirect, returnTo, "not_configured");
+
+	const user = (await session?.get("user")) as { id?: string } | undefined;
+	if (!user?.id) return redirect(signInUrl(returnTo));
+	try {
+		const d = await discover(config);
+		return redirect(new URL("/", d.authorizationEndpoint).href);
+	} catch {
+		return fail(redirect, returnTo, "account_unavailable");
+	}
+};

package/src/routes/buy.ts

@@ -1,8 +1,9 @@
 /**
- * POST /_emdash/api/auth/redeemid/buy: start a Shopify checkout for one plan.
+ * POST /_emdash/api/auth/redeemid/buy: add a plan to the cart and check out.
  *
  * Takes a product handle, looks its variant up again on Shopify (never
- * trusting a posted variant or price) and sends the buyer to checkout. A
+ * trusting a posted variant or price), adds it to the visitor's Shopify
+ * cart and sends them to that cart's checkout. A
  * signed-in member's email is passed along so the order lands on the same
  * customer. Tags, and so access, still only change when Shopify says so.
  */
@@ -12,7 +13,8 @@ import type { APIRoute } from "astro";
 import { readConfig, storeDomain } from "../config.js";
 import { safeReturn } from "../access.js";
 import { memberForUser, stores } from "../storage.js";
-import { checkoutUrl, plan } from "../storefront.js";
+import { saveCart, readCart } from "../cart.js";
+import { addToCart, plan } from "../storefront.js";
 import { fail } from "./shared.js";
 
 export const prerender = false;
@@ -32,12 +34,15 @@ export const POST: APIRoute = async ({ request, locals, session, redirect }) =>
 		// Provider routes are public, so read the member from the session.
 		const user = (await session?.get("user")) as { id?: string } | undefined;
 		const member = user?.id && emdash?.db ? await memberForUser(stores(emdash.db), user.id) : null;
-		const to = await checkoutUrl(
+		const current = await readCart(session);
+		const cart = await addToCart(
 			config,
+			current?.id ?? null,
 			{ variantId: p.variantId, sellingPlanId: p.sellingPlanId },
 			{ email: member?.email ?? null, buyerIp: request.headers.get("cf-connecting-ip") },
 		);
-		return redirect(to, 303);
+		saveCart(session, { id: cart.id, count: cart.totalQuantity });
+		return redirect(cart.checkoutUrl, 303);
 	} catch {
 		return fail(redirect, returnTo, "checkout_failed");
 	}

package/src/routes/cart.ts

@@ -0,0 +1,37 @@
+/**
+ * GET /_emdash/api/auth/redeemid/cart?return=/path
+ *
+ * Sends the visitor to their Shopify cart's checkout. With no cart, or one
+ * Shopify has closed (its checkout completed), they go back with the
+ * `cart_empty` notice and the stored cart is cleared.
+ */
+
+import type { APIRoute } from "astro";
+
+import { safeReturn } from "../access.js";
+import { readCart, saveCart } from "../cart.js";
+import { readConfig, storeDomain } from "../config.js";
+import { getCart } from "../storefront.js";
+import { fail } from "./shared.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ request, locals, session, redirect }) => {
+	const returnTo = safeReturn(new URL(request.url).searchParams.get("return"));
+	const config = readConfig((locals as { emdash?: { config?: unknown } }).emdash?.config);
+	if (!config || !storeDomain(config)) return fail(redirect, returnTo, "not_configured");
+
+	const ref = await readCart(session);
+	if (!ref) return fail(redirect, returnTo, "cart_empty");
+	try {
+		const cart = await getCart(config, ref.id, { buyerIp: request.headers.get("cf-connecting-ip") });
+		if (!cart || cart.totalQuantity < 1) {
+			saveCart(session, null);
+			return fail(redirect, returnTo, "cart_empty");
+		}
+		saveCart(session, { id: cart.id, count: cart.totalQuantity });
+		return redirect(cart.checkoutUrl, 303);
+	} catch {
+		return fail(redirect, returnTo, "checkout_failed");
+	}
+};

package/src/shopify.ts

@@ -24,6 +24,12 @@ const DISCOVERY_TTL_MS = 60 * 60 * 1000;
 const discoveryCache = new Map<string, { at: number; value: Discovery }>();
 const jwksCache = new Map<string, ReturnType<typeof createRemoteJWKSet>>();
 
+/**
+ * Shopify answers 403 to requests with no User-Agent, and fetch on
+ * Cloudflare Workers sends none, so every server-side call names itself.
+ */
+export const USER_AGENT = "@redeemid/emdash (+https://github.com/webmultipliers/redeemid-emdash)";
+
 export class ShopifyError extends Error {
 	constructor(
 		public readonly code: string,
@@ -65,7 +71,7 @@ export async function discover(config: RedeemIDConfig, fetcher: typeof fetch = f
 }
 
 async function getJson(fetcher: typeof fetch, url: string): Promise<Record<string, unknown>> {
-	const res = await fetcher(url, { headers: { Accept: "application/json" } });
+	const res = await fetcher(url, { headers: { Accept: "application/json", "User-Agent": USER_AGENT } });
 	if (!res.ok) throw new ShopifyError("discovery_failed", `Discovery failed (${res.status}) for ${url}`);
 	return (await res.json()) as Record<string, unknown>;
 }
@@ -128,6 +134,7 @@ export async function exchangeCode(
 	const headers: Record<string, string> = {
 		"Content-Type": "application/x-www-form-urlencoded",
 		Accept: "application/json",
+		"User-Agent": USER_AGENT,
 	};
 	// Public clients are checked against their registered JavaScript origins.
 	if (args.origin) headers.Origin = args.origin;
@@ -149,7 +156,7 @@ export async function verifyIdToken(
 ): Promise<JWTPayload> {
 	let jwks = jwksCache.get(d.jwksUri);
 	if (!jwks) {
-		jwks = createRemoteJWKSet(new URL(d.jwksUri));
+		jwks = createRemoteJWKSet(new URL(d.jwksUri), { headers: { "User-Agent": USER_AGENT } });
 		jwksCache.set(d.jwksUri, jwks);
 	}
 	try {
@@ -191,7 +198,7 @@ export async function identity(d: Discovery, accessToken: string, fetcher: typeo
 	const res = await fetcher(d.graphqlApi, {
 		method: "POST",
 		// The Customer Account API takes the bare access token, without "Bearer".
-		headers: { "Content-Type": "application/json", Authorization: accessToken },
+		headers: { "Content-Type": "application/json", Authorization: accessToken, "User-Agent": USER_AGENT },
 		body: JSON.stringify({ query: IDENTITY_QUERY }),
 	});
 	const data = (await res.json().catch(() => ({}))) as {

package/src/storefront.ts

@@ -8,6 +8,7 @@
  */
 
 import { env, ENV, shopOrigin, type RedeemIDConfig } from "./config.js";
+import { USER_AGENT } from "./shopify.js";
 
 export const STOREFRONT_API_VERSION = "2026-10";
 
@@ -34,7 +35,11 @@ export async function storefront<T>(
 	variables: Record<string, unknown> = {},
 	opts: { buyerIp?: string | null; fetcher?: typeof fetch } = {},
 ): Promise<T> {
-	const headers: Record<string, string> = { "Content-Type": "application/json", Accept: "application/json" };
+	const headers: Record<string, string> = {
+		"Content-Type": "application/json",
+		Accept: "application/json",
+		"User-Agent": USER_AGENT,
+	};
 	const priv = env(ENV.storefrontPrivateToken);
 	const pub = env(ENV.storefrontPublicToken);
 	if (priv) {
@@ -121,3 +126,61 @@ export async function checkoutUrl(
 	if (!url) throw new Error(data.cartCreate.userErrors[0]?.message ?? "Shopify returned no checkout.");
 	return url;
 }
+
+// ---------------------------------------------------------------- cart
+
+export interface Cart {
+	id: string;
+	checkoutUrl: string;
+	totalQuantity: number;
+}
+
+const CART_FIELDS = "id checkoutUrl totalQuantity";
+
+const CART_GET = `query Cart($id: ID!) { cart(id: $id) { ${CART_FIELDS} } }`;
+
+const CART_NEW = `mutation CartNew($input: CartInput!) {
+  cartCreate(input: $input) { cart { ${CART_FIELDS} } userErrors { message } }
+}`;
+
+const CART_ADD = `mutation CartAdd($id: ID!, $lines: [CartLineInput!]!) {
+  cartLinesAdd(cartId: $id, lines: $lines) { cart { ${CART_FIELDS} } userErrors { message } }
+}`;
+
+type CartResult = { cart: Cart | null; userErrors: Array<{ message: string }> };
+
+/**
+ * A cart by id. Null once Shopify no longer has it, which is what happens
+ * after its checkout completes.
+ */
+export async function getCart(
+	config: RedeemIDConfig,
+	id: string,
+	opts: { buyerIp?: string | null; fetcher?: typeof fetch } = {},
+): Promise<Cart | null> {
+	const data = await storefront<{ cart: Cart | null }>(config, CART_GET, { id }, opts);
+	return data.cart;
+}
+
+/**
+ * Add one line to the visitor's cart, creating the cart when there is none
+ * (or Shopify has dropped it). A new cart carries the member's email.
+ */
+export async function addToCart(
+	config: RedeemIDConfig,
+	cartId: string | null,
+	line: { variantId: string; sellingPlanId?: string | null },
+	opts: { email?: string | null; buyerIp?: string | null; fetcher?: typeof fetch } = {},
+): Promise<Cart> {
+	const lines = [{ merchandiseId: line.variantId, quantity: 1, ...(line.sellingPlanId ? { sellingPlanId: line.sellingPlanId } : {}) }];
+	if (cartId) {
+		const data = await storefront<{ cartLinesAdd: CartResult }>(config, CART_ADD, { id: cartId, lines }, opts).catch(() => null);
+		if (data?.cartLinesAdd.cart) return data.cartLinesAdd.cart;
+	}
+	const input: Record<string, unknown> = { lines };
+	if (opts.email) input.buyerIdentity = { email: opts.email };
+	const data = await storefront<{ cartCreate: CartResult }>(config, CART_NEW, { input }, opts);
+	const cart = data.cartCreate.cart;
+	if (!cart) throw new Error(data.cartCreate.userErrors[0]?.message ?? "Shopify returned no cart.");
+	return cart;
+}

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = "0.0.3";