@redeemid/emdash 0.0.16 → 0.0.18

package/src/settings.ts

@@ -0,0 +1,195 @@
+/**
+ * Access settings made in the admin.
+ *
+ * Levels, rules, the meter, protected folders and the rest can be set in
+ * astro.config.mjs (the defaults) and changed in the admin (Plugins →
+ * RedeemID → Access). A setting saved in the admin replaces the code's value
+ * for that setting; "Use the code's value" removes it again. Each entry can
+ * also carry its own rule, set in the editor's Access panel.
+ *
+ * Saved in the auth-provider storage collection `access`: record `site` for
+ * the site settings and `entry:<id>` for each entry's own rule. Nothing here
+ * grants access to anyone: levels still come only from Shopify tags.
+ */
+
+import type { FeatureConfig, FileRule, LevelConfig, MeterConfig, RedeemIDConfig, RuleConfig } from "./config.js";
+import type { StorageCollection } from "emdash";
+
+import { stores } from "./storage.js";
+
+/** The settings the admin can manage, by config key. */
+export const MANAGED = ["levels", "rules", "meter", "files", "features", "combine", "teaser", "join"] as const;
+export type ManagedKey = (typeof MANAGED)[number];
+
+/** What the admin saved. A key that's present replaces the code's value (null turns it off). */
+export interface SiteAccess {
+	kind: "site";
+	levels?: LevelConfig[];
+	rules?: RuleConfig[];
+	meter?: MeterConfig | null;
+	files?: FileRule[];
+	features?: FeatureConfig[];
+	combine?: "all" | "any";
+	teaser?: Record<string, number>;
+	join?: { href: string; label?: string } | null;
+	updatedAt?: string;
+}
+
+/**
+ * One entry's own rule, set in the editor:
+ *
+ * - inherit: the site's rules decide (the default).
+ * - open: free to everyone.
+ * - levels: only the levels picked (none picked means any signed-in member).
+ * - add: the site's rules, and also one of the levels picked.
+ *
+ * `lockedUntil` opens the entry to everyone from that time; `openUntil` keeps
+ * it free to everyone until that time. `drip` and `meter: false` work as on
+ * a rule.
+ */
+export interface EntryRule {
+	kind: "entry";
+	collection: string;
+	/** EmDash's id for the entry. */
+	entryId: string;
+	/** Its slug when last saved, so page code can pass either. */
+	slug?: string | null;
+	mode: "inherit" | "open" | "levels" | "add";
+	levels: string[];
+	drip?: number;
+	meter?: false;
+	lockedUntil?: string | null;
+	openUntil?: string | null;
+	updatedAt?: string;
+}
+
+export type AccessRecord = SiteAccess | EntryRule;
+
+export interface LoadedAccess {
+	site: SiteAccess | null;
+	entries: EntryRule[];
+}
+
+export const SITE_ID = "site";
+export const entryKey = (entryId: string) => `entry:${entryId}`;
+
+/** Read everything saved, in one query. */
+export async function loadAccess(store: StorageCollection<AccessRecord>): Promise<LoadedAccess> {
+	const out: LoadedAccess = { site: null, entries: [] };
+	let cursor: string | undefined;
+	let pages = 0;
+	do {
+		const page = await store.query({ limit: 1000, cursor });
+		for (const r of page.items) {
+			if (r.data?.kind === "site") out.site = r.data;
+			else if (r.data?.kind === "entry") out.entries.push(r.data);
+		}
+		cursor = page.cursor;
+	} while (cursor && ++pages < 10);
+	return out;
+}
+
+/** The code's config with the admin's settings and entry rules laid over it. */
+export function mergeAccess(code: RedeemIDConfig | null, saved: LoadedAccess | null): RedeemIDConfig | null {
+	if (!code) return null;
+	if (!saved) return code;
+	const out: Record<string, unknown> = { ...code };
+	const site = saved.site as Record<string, unknown> | null;
+	if (site) {
+		for (const key of MANAGED) {
+			if (!(key in site)) continue;
+			const value = site[key];
+			if (value === null || value === undefined) delete out[key];
+			else out[key] = value;
+		}
+	}
+	const entries: Record<string, EntryRule> = {};
+	for (const e of saved.entries) {
+		if (e.mode === "inherit" && !e.drip && e.meter !== false && !e.lockedUntil && !e.openUntil) continue;
+		entries[`${e.collection}:${e.entryId}`] = e;
+		if (e.slug) entries[`${e.collection}:${e.slug}`] ??= e;
+	}
+	out.entries = { ...(code.entries ?? {}), ...entries };
+	return out as RedeemIDConfig;
+}
+
+/** Which settings the admin has taken over from the code. */
+export function overridden(site: SiteAccess | null): Set<ManagedKey> {
+	return new Set(MANAGED.filter((k) => site && k in site));
+}
+
+/** Code config plus the admin's settings, read with `db`. */
+export async function withSaved(code: RedeemIDConfig | null, db: unknown): Promise<RedeemIDConfig | null> {
+	if (!code) return null;
+	try {
+		const merged = mergeAccess(code, await loadAccess(stores(db).access));
+		announceLevels(merged?.levels);
+		return merged;
+	} catch (e) {
+		// No storage yet (or it can't be read): the code's settings stand.
+		console.error("[redeemid] couldn't read saved access settings:", (e as Error).message);
+		return code;
+	}
+}
+
+// ---------------------------------------------------------------- level pickers
+
+type LevelListener = (levels: LevelConfig[]) => void;
+const LISTENERS = Symbol.for("redeemid:level-listeners");
+
+/**
+ * The editor's level pickers (on the Paywall break and other blocks) are
+ * declared when the plugin starts. The plugin registers a listener here so
+ * they follow levels saved in the admin.
+ */
+export function onLevels(listener: LevelListener): void {
+	const g = globalThis as unknown as Record<symbol, LevelListener[]>;
+	(g[LISTENERS] ??= []).push(listener);
+}
+
+export function announceLevels(levels: LevelConfig[] = []): void {
+	const g = globalThis as unknown as Record<symbol, LevelListener[] | undefined>;
+	for (const l of g[LISTENERS] ?? []) {
+		try {
+			l(levels);
+		} catch {
+			// A listener's failure never breaks a page.
+		}
+	}
+}
+
+// ---------------------------------------------------------------- checks
+
+const SLUG = /^[a-z0-9][a-z0-9_-]{0,62}$/;
+
+/** A slug from a name: "Gold members" → "gold-members". */
+export function slugify(raw: string): string {
+	return raw
+		.toLowerCase()
+		.normalize("NFKD")
+		.replace(/[̀-ͯ]/g, "")
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+		.slice(0, 63);
+}
+
+export function validSlug(slug: string): boolean {
+	return SLUG.test(slug) && slug !== "signed-in";
+}
+
+/** Comma- or line-separated text to a trimmed, unique list. */
+export function list(raw: unknown): string[] {
+	const parts = Array.isArray(raw) ? raw : String(raw ?? "").split(/[,\n]/);
+	const out: string[] = [];
+	for (const p of parts) {
+		const t = String(p).trim();
+		if (t && !out.some((o) => o.toLowerCase() === t.toLowerCase())) out.push(t);
+	}
+	return out;
+}
+
+/** A whole number of days, 0 to 3650. */
+export function days(raw: unknown): number {
+	const n = Math.floor(Number(raw));
+	return Number.isFinite(n) && n > 0 ? Math.min(n, 3650) : 0;
+}

package/src/shopify.ts

@@ -127,6 +127,42 @@ export function authorizeUrl(
 export interface Tokens {
 	accessToken: string;
 	idToken: string;
+	/** Present when Shopify issued one; used to renew the access token for a signed-in checkout. */
+	refreshToken?: string | null;
+	/** When the access token expires (ms since epoch), when Shopify said. */
+	expiresAt?: number | null;
+}
+
+function tokenTimes(data: Record<string, unknown>): { refreshToken: string | null; expiresAt: number | null } {
+	const ttl = typeof data.expires_in === "number" ? data.expires_in : Number(data.expires_in);
+	return {
+		refreshToken: typeof data.refresh_token === "string" ? data.refresh_token : null,
+		expiresAt: Number.isFinite(ttl) && ttl > 0 ? Date.now() + ttl * 1000 : null,
+	};
+}
+
+/**
+ * Renew a Customer Account API access token with its refresh token. Throws
+ * when Shopify refuses (the member's store session ended).
+ */
+export async function refreshTokens(
+	d: Discovery,
+	args: { clientId: string; clientSecret: string; origin?: string; refreshToken: string },
+	fetcher: typeof fetch = fetch,
+): Promise<{ accessToken: string; refreshToken: string | null; expiresAt: number | null }> {
+	const body = new URLSearchParams({ grant_type: "refresh_token", client_id: args.clientId, refresh_token: args.refreshToken });
+	const headers: Record<string, string> = {
+		"Content-Type": "application/x-www-form-urlencoded",
+		Accept: "application/json",
+		"User-Agent": USER_AGENT,
+	};
+	if (args.origin) headers.Origin = args.origin;
+	if (args.clientSecret) headers.Authorization = `Basic ${btoa(`${args.clientId}:${args.clientSecret}`)}`;
+	const res = await fetcher(d.tokenEndpoint, { method: "POST", headers, body });
+	const data = (await res.json().catch(() => ({}))) as Record<string, unknown>;
+	if (!res.ok || typeof data.access_token !== "string") throw new ShopifyError("token_failed", `Token refresh failed (${res.status}).`);
+	const t = tokenTimes(data);
+	return { accessToken: data.access_token, refreshToken: t.refreshToken ?? args.refreshToken, expiresAt: t.expiresAt };
 }
 
 export async function exchangeCode(
@@ -155,7 +191,7 @@ export async function exchangeCode(
 	if (!res.ok || typeof data.access_token !== "string" || typeof data.id_token !== "string") {
 		throw new ShopifyError("token_failed", `Token exchange failed (${res.status}).`);
 	}
-	return { accessToken: data.access_token, idToken: data.id_token };
+	return { accessToken: data.access_token, idToken: data.id_token, ...tokenTimes(data) };
 }
 
 /** Verify the ID token's signature, issuer, audience, expiry and nonce. */

package/src/site-config.ts

@@ -1,15 +1,48 @@
 /**
- * The site's RedeemID config at request time.
+ * The site's RedeemID config at request time: the code's config (from
+ * astro.config.mjs) with the settings saved in the admin laid over it.
  *
  * EmDash's anonymous fast path leaves `locals.emdash` without its config, so
- * page checks read the integration's serialized config module instead. That
- * module only exists inside the site's Vite build.
+ * the code's config is read from the integration's serialized config module
+ * when it's missing. That module only exists inside the site's Vite build.
+ *
+ * The saved settings are read once per request (one query) and shared by
+ * everything that asks during it.
  */
 // @ts-expect-error -- virtual module provided by the EmDash integration
 import virtualConfig from "virtual:emdash/config";
 
 import { readConfig, type RedeemIDConfig } from "./config.js";
+import { withSaved } from "./settings.js";
+
+type Locals = { emdash?: { config?: unknown; db?: unknown } | null } | null | undefined;
+
+const loaded = new WeakMap<object, Promise<RedeemIDConfig | null>>();
+
+/** The code's config only, without the admin's settings. */
+export function codeConfig(locals?: unknown): RedeemIDConfig | null {
+	return readConfig((locals as Locals)?.emdash?.config) ?? readConfig(virtualConfig);
+}
+
+async function database(locals: Locals): Promise<unknown> {
+	if (locals?.emdash?.db) return locals.emdash.db;
+	const { getDb } = await import("emdash/runtime");
+	return getDb();
+}
+
+/** The site's config for this request (pass `Astro.locals` or the route's `locals`). */
+export function siteConfig(locals?: unknown): Promise<RedeemIDConfig | null> {
+	const key = locals && typeof locals === "object" ? (locals as object) : null;
+	const known = key ? loaded.get(key) : undefined;
+	if (known) return known;
+	const code = codeConfig(locals);
+	const fresh = code ? database(locals as Locals).then((db) => withSaved(code, db), () => code) : Promise.resolve(null);
+	if (key) loaded.set(key, fresh);
+	return fresh;
+}
 
-export function siteConfig(emdashConfig?: unknown): RedeemIDConfig | null {
-	return readConfig(emdashConfig) ?? readConfig(virtualConfig);
+/** Share an already-read config with a copy of the request's locals. */
+export function shareConfig(from: unknown, to: unknown): void {
+	const known = from && typeof from === "object" ? loaded.get(from as object) : undefined;
+	if (known && to && typeof to === "object") loaded.set(to as object, known);
 }

package/src/staff.ts

@@ -1,14 +1,15 @@
 /**
  * Staff tools in the admin (Block Kit): member detail with Resync and tag
  * edits written to Shopify, a paced manual bulk resync, webhook
- * registration and health, recent deliveries and the access test.
+ * registration and the access test.
  */
 
 import { adminConfigured, adminScopes, editTags, registerWebhooks, resync, webhookSubscriptions, WEBHOOK_TOPICS } from "./admin-api.js";
-import { describe, levelsFor, membership, passes, requirement, termTree, type Terms } from "./access.js";
+import { applyEntryRule, describe, entryRuleFor, levelsFor, membership, passes, requirement, termTree, type Terms } from "./access.js";
 import type { RedeemIDConfig } from "./config.js";
 import { levelChange } from "./events.js";
 import { featuresFor } from "./features.js";
+import { record } from "./log.js";
 import { recentRequests } from "./privacy.js";
 import { cleanTags, numericId, type MemberRecord, type Stores } from "./storage.js";
 
@@ -193,6 +194,7 @@ export async function bulkResync(config: RedeemIDConfig, s: Stores): Promise<{ d
 		if (was.join("\n") !== m.tags.join("\n")) changed++;
 		await levelChange(config, was, m, "bulk resync");
 	}
+	await record({ event: "staff.resync", label: "bulk", status: `${updated.length} read, ${changed} changed${missing.length ? `, ${missing.length} missing` : ""}`, origin: "staff" });
 	return { done: updated.length, missing: missing.length, changed };
 }
 
@@ -201,13 +203,16 @@ export async function resyncOne(config: RedeemIDConfig, s: Stores, customerId: s
 	const { updated } = await resync(config, s, [customerId], source);
 	const m = updated[0] ?? null;
 	if (m) await levelChange(config, before?.tags ?? null, m, source);
+	await record({ event: "staff.resync", label: source, status: m ? "ok" : "not in Shopify", level: m ? "ok" : "warn", origin: source.startsWith("agent") ? "agent" : "staff", customerId });
 	return m;
 }
 
 export async function tagEdit(config: RedeemIDConfig, s: Stores, customerId: string, change: "add" | "remove", raw: unknown): Promise<MemberRecord | null> {
 	const id = numericId(customerId);
 	if (!id) return null;
-	await editTags(config, id, change, cleanTags(raw));
+	const tags = cleanTags(raw);
+	await editTags(config, id, change, tags);
+	await record({ event: "staff.tags", label: change === "add" ? "added" : "removed", status: "ok", origin: "staff", customerId: id, note: tags.join(", ").slice(0, 200) });
 	return resyncOne(config, s, id, change === "add" ? "staff added tags" : "staff removed tags");
 }
 
@@ -225,7 +230,7 @@ export async function webhooksSection(config: RedeemIDConfig, uri: string): Prom
 		});
 		const missing = rows.filter((r) => r.state !== "Registered").length;
 		return [
-			{ type: "fields", fields: [{ label: "Admin API", value: `Connected (${scope || "no scopes reported"})` }, { label: "Webhook address", value: uri }] },
+			{ type: "section", text: `Admin API: connected (${scope || "no scopes reported"}).` },
 			{ type: "table", page_action_id: "webhooks", columns: [{ key: "topic", label: "Topic" }, { key: "state", label: "Sends here", format: "badge" }], rows },
 			missing
 				? { type: "actions", elements: [{ type: "button", action_id: "webhooks_register", label: `Register ${missing} missing`, style: "primary", value: uri }] }
@@ -236,24 +241,6 @@ export async function webhooksSection(config: RedeemIDConfig, uri: string): Prom
 	}
 }
 
-export async function deliveriesSection(s: Stores): Promise<unknown[]> {
-	const { items } = await s.deliveries.query({ orderBy: { receivedAt: "desc" }, limit: 20 });
-	return items.length
-		? [
-				{
-					type: "table",
-					page_action_id: "deliveries",
-					columns: [
-						{ key: "topic", label: "Topic", format: "code" },
-						{ key: "at", label: "Received", format: "relative_time" },
-						{ key: "id", label: "Delivery" },
-					],
-					rows: items.map((r) => ({ topic: r.data.topic, at: r.data.receivedAt, id: r.id })),
-				},
-			]
-		: [{ type: "context", text: "No webhooks received yet." }];
-}
-
 export { registerWebhooks };
 
 /** "category:pro, tag:weekend" → { category: ["pro"], tag: ["weekend"] } */
@@ -269,6 +256,7 @@ export function parseTerms(raw: string): Terms {
 /** The access test: what an entry needs, and whether a reader with these tags passes. */
 export async function accessTest(config: RedeemIDConfig, values: Record<string, unknown> = {}): Promise<Blocks> {
 	const collection = String(values.collection ?? "").trim();
+	const entryId = String(values.entry ?? "").trim();
 	const termsRaw = String(values.terms ?? "").trim();
 	const tags = cleanTags(String(values.tags ?? ""));
 	const signedIn = values.signed_in !== false;
@@ -278,6 +266,7 @@ export async function accessTest(config: RedeemIDConfig, values: Record<string,
 		block_id: "access_test",
 		fields: [
 			{ type: "text_input", action_id: "collection", label: "Collection", placeholder: "posts", initial_value: collection },
+			{ type: "text_input", action_id: "entry", label: "Entry id or slug (optional: applies its own rule)", initial_value: entryId },
 			{ type: "text_input", action_id: "terms", label: "Terms (taxonomy:slug, comma separated)", placeholder: "category:investigations, tag:free-to-read", initial_value: termsRaw },
 			{ type: "text_input", action_id: "tags", label: "Reader's Shopify tags (comma separated)", placeholder: "gold-member", initial_value: tags.join(", ") },
 			{ type: "toggle", action_id: "signed_in", label: "Signed in", initial_value: signedIn },
@@ -292,7 +281,7 @@ export async function accessTest(config: RedeemIDConfig, values: Record<string,
 	if (collection) {
 		const terms = parseTerms(termsRaw);
 		const tree = await termTree(config.rules, collection, terms);
-		const required = requirement(config.rules, collection, terms, { combine: config.combine, tree });
+		const required = applyEntryRule(requirement(config.rules, collection, terms, { combine: config.combine, tree }), entryRuleFor(config, collection, entryId));
 		const held = levelsFor(tags, levels);
 		const ok = required === null || (signedIn && passes(held, required));
 		out.push(

package/src/storage.ts

@@ -11,6 +11,8 @@ import type { StorageCollection } from "emdash";
 import { getAuthProviderStorage } from "emdash/api/route-utils";
 
 import { PROVIDER_ID } from "./config.js";
+import type { AccessRecord } from "./settings.js";
+import type { LogEntry } from "./log.js";
 
 export interface MemberRecord {
 	/** Numeric Shopify customer id, also the record id. */
@@ -77,6 +79,10 @@ export function stampTags(m: MemberRecord, now = new Date().toISOString()): Memb
 export interface DeliveryRecord {
 	topic: string;
 	receivedAt: string;
+	/** What became of it: processed, skipped, stale, ignored, or pending while it runs. */
+	outcome?: string;
+	/** The Shopify customer it was about, when it named one. */
+	customerId?: string | null;
 }
 
 /** One privacy request: an export or erase, and where it came from. Names no one but the customer id. */
@@ -97,6 +103,8 @@ export const STORAGE_CONFIG = {
 	deliveries: { indexes: ["receivedAt"] },
 	meter: { indexes: ["userId"] },
 	requests: { indexes: ["at", "customerId", "status"] },
+	access: { indexes: ["kind"] },
+	log: { indexes: ["at", "event", "level"] },
 };
 
 export interface Stores {
@@ -104,6 +112,10 @@ export interface Stores {
 	deliveries: StorageCollection<DeliveryRecord>;
 	meter: StorageCollection<MeterRecord>;
 	requests: StorageCollection<PrivacyRequest>;
+	/** Access settings saved in the admin and editor (see settings.ts). */
+	access: StorageCollection<AccessRecord>;
+	/** App events (see log.ts). */
+	log: StorageCollection<LogEntry>;
 }
 
 export function stores(db: unknown): Stores {