@redeemid/emdash 0.0.15 → 0.0.17

package/src/files.ts

@@ -101,7 +101,7 @@ async function readsWhole(astro: AstroLike, entry: { collection: string; id: str
 		const m = (await viewer(astro)).member;
 		if (m && m.status !== "disabled" && holdsItem(item, m.tags)) return true;
 	}
-	const verdict = await readEntry(astro, { collection: entry.collection, terms });
+	const verdict = await readEntry(astro, { collection: entry.collection, terms, ruleId: entry.id });
 	if (!verdict.allowed) return false;
 	const clauses = bodyClauses(body);
 	return clauses.every((clause) => clause.some((l) => verdict.viewer.levels.includes(l) || (l === "signed-in" && verdict.viewer.signedIn)));

package/src/guard.ts

@@ -25,7 +25,7 @@ import { signInUrl } from "./access.js";
 import { readCart } from "./cart.js";
 import { keysFromPath, pathAccess, refusal } from "./files.js";
 import { AFTER_LOGOUT_COOKIE, readAfterLogout } from "./routes/shared.js";
-import { siteConfig } from "./site-config.js";
+import { shareConfig, siteConfig } from "./site-config.js";
 
 const SUBSCRIBER = 10;
 
@@ -55,7 +55,9 @@ async function withUser(context: { locals: unknown; session?: { get(k: string):
 	const { createKyselyAdapter } = await import("@emdash-cms/auth/adapters/kysely");
 	const user = await createKyselyAdapter(locals.emdash.db as never).getUserById(sessionUser.id);
 	if (!user || user.disabled) return context;
-	return { ...context, locals: { ...locals, user: { id: user.id, role: user.role, disabled: user.disabled } } };
+	const next = { ...locals, user: { id: user.id, role: user.role, disabled: user.disabled } };
+	shareConfig(locals, next);
+	return { ...context, locals: next };
 }
 
 /** Keep one visitor's response out of every shared cache, the route cache included. */
@@ -75,7 +77,7 @@ export function keepPrivate(context: { cache?: { set(options: false): void } },
 export const onRequest = defineMiddleware(async (context, next) => {
 	const { locals, url } = context;
 	const user = (locals as { user?: { role?: number } | null }).user;
-	const config = siteConfig((locals as { emdash?: { config?: unknown } }).emdash?.config);
+	const config = await siteConfig(locals);
 
 	// Protected files: checked for everyone, on every download.
 	const keys = config?.files?.length ? keysFromPath(url.pathname) : null;

package/src/index.ts

@@ -70,11 +70,14 @@ export function redeemid(config: RedeemIDConfig): AuthProviderDescriptor {
  * Astro integration that keeps members (EmDash Subscribers) out of EmDash's
  * content API and admin, so only RedeemID's checks decide who reads what.
  */
-export function redeemidGuard(): AstroIntegration {
+export function redeemidGuard(options: { rateLimit?: boolean } = {}): AstroIntegration {
 	return {
 		name: "@redeemid/emdash/guard",
 		hooks: {
 			"astro:config:setup": ({ addMiddleware }) => {
+				// Cloudflare Workers only: limits Sign in, Buy and cart changes per
+				// visitor with the REDEEMID_RATE_LIMIT Rate Limiting binding.
+				if (options.rateLimit) addMiddleware({ entrypoint: "@redeemid/emdash/rate-limit-cloudflare.ts", order: "pre" });
 				addMiddleware({ entrypoint: "@redeemid/emdash/guard.ts", order: "post" });
 			},
 		},

package/src/log.ts

@@ -0,0 +1,96 @@
+/**
+ * App events: what RedeemID did and what came of it, for the admin's App
+ * events page. Webhooks received and rejected, sign-ins and refusals, calls to
+ * Shopify's Admin API, staff actions, settings saves and outbound events.
+ *
+ * Each entry holds ids, labels, outcomes and timings only, never request or
+ * response bodies, tokens or emails. Kept 30 days.
+ */
+
+import type { StorageCollection } from "emdash";
+
+export const LOG_DAYS = 30;
+
+export type LogOrigin = "webhook" | "member" | "staff" | "agent" | "cron" | "site";
+
+export interface LogEntry {
+	at: string;
+	/** Dotted name, e.g. "webhook.received", "shopify.admin". */
+	event: string;
+	/** What it was about, e.g. a webhook topic or an Admin API operation. */
+	label: string;
+	/** ok, or what went wrong, e.g. "processed", "rejected", "error". */
+	status: string;
+	/** "ok" | "warn" | "error", for colour and the Problems filter. */
+	level: "ok" | "warn" | "error";
+	origin?: LogOrigin;
+	customerId?: string | null;
+	ms?: number;
+	/** A short note, never a body or a secret. */
+	note?: string;
+}
+
+/** Event names, for the filter. */
+export const LOG_EVENTS: Record<string, string> = {
+	"webhook.received": "Webhook received",
+	"webhook.rejected": "Webhook rejected",
+	"webhook.failed": "Webhook failed",
+	"webhook.quiet": "No webhooks lately",
+	"member.signed_in": "Sign-in",
+	"member.refused": "Sign-in refused",
+	"shopify.admin": "Admin API call",
+	"staff.resync": "Resync",
+	"staff.tags": "Tag edit",
+	"staff.webhooks": "Webhook registration",
+	"settings.saved": "Settings saved",
+	"events.failed": "Outbound event failed",
+	"health.check": "Health check",
+	"meter.used": "Metered read",
+	"meter.exhausted": "Metered read, meter used up",
+};
+
+type Sink = (entry: LogEntry) => Promise<void>;
+const SINK = Symbol.for("redeemid:log-sink");
+
+/** Where entries go (the plugin's storage, or a test's array). */
+export function setLogSink(sink: Sink | null): void {
+	(globalThis as unknown as Record<symbol, Sink | null>)[SINK] = sink;
+}
+
+async function defaultSink(entry: LogEntry): Promise<void> {
+	const [{ getDb }, { stores }] = await Promise.all([import("emdash/runtime"), import("./storage.js")]);
+	const s = stores(await getDb());
+	await s.log.put(`${entry.at}:${crypto.randomUUID().slice(0, 8)}`, entry);
+}
+
+/** Record one entry. Never throws: a log that can't be written never breaks the work. */
+export async function record(entry: Omit<LogEntry, "at" | "level"> & { level?: LogEntry["level"] }): Promise<void> {
+	const full: LogEntry = { at: new Date().toISOString(), level: entry.level ?? "ok", ...entry } as LogEntry;
+	try {
+		const sink = (globalThis as unknown as Record<symbol, Sink | null | undefined>)[SINK] ?? defaultSink;
+		await sink(full);
+	} catch {
+		// No storage here (e.g. outside a request): skip.
+	}
+}
+
+/** Time a call and record it. */
+export async function timed<T>(event: string, label: string, run: () => Promise<T>, extra: Partial<LogEntry> = {}): Promise<T> {
+	const started = Date.now();
+	try {
+		const out = await run();
+		await record({ event, label, status: "ok", ms: Date.now() - started, ...extra });
+		return out;
+	} catch (e) {
+		await record({ event, label, status: "error", level: "error", ms: Date.now() - started, note: String((e as Error).message ?? e).slice(0, 200), ...extra });
+		throw e;
+	}
+}
+
+/** Delete entries (and other dated records) older than `days`, a page at a time. */
+export async function prune<T>(store: StorageCollection<T>, field: string, days = LOG_DAYS): Promise<number> {
+	const before = new Date(Date.now() - days * 86_400_000).toISOString();
+	const { items } = await store.query({ where: { [field]: { lt: before } }, limit: 100 });
+	if (items.length === 0) return 0;
+	return store.deleteMany(items.map((i) => i.id));
+}