@wtfalch/reporting 0.1.1 → 0.2.1

package/dist/react/index.js

@@ -0,0 +1,52 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { createBeacon, } from '../browser/index.js';
+const ReportingContext = createContext({
+    beacon: null,
+    answer: null,
+    mode: 'none',
+    accept: () => undefined,
+    decline: () => undefined,
+});
+export function ReportingProvider(props) {
+    const [beacon, setBeacon] = useState(null);
+    const [answer, setAnswer] = useState(null);
+    const mode = props.consent ?? 'consented';
+    useEffect(() => {
+        const b = createBeacon({ collector: props.collector, site: props.site, consent: mode });
+        setBeacon(b);
+        setAnswer(b.answer());
+        return () => b.destroy();
+    }, [props.collector, props.site, mode]);
+    const value = useMemo(() => ({
+        beacon,
+        answer,
+        mode,
+        accept() {
+            beacon?.accept();
+            setAnswer(beacon?.answer() ?? null);
+        },
+        decline() {
+            beacon?.decline();
+            setAnswer(beacon?.answer() ?? null);
+        },
+    }), [beacon, answer, mode]);
+    return _jsx(ReportingContext.Provider, { value: value, children: props.children });
+}
+/** `track(name, props)` from a client component; a no-op before the beacon mounts. */
+export function useTrack() {
+    const { beacon } = useContext(ReportingContext);
+    return (name, props) => beacon?.track(name, props);
+}
+/**
+ * The consent question, shown only under `consented` and only until it is
+ * answered. The host supplies the words; the control supplies the two
+ * buttons and remembers the answer through the beacon's cookie.
+ */
+export function ConsentControl(props) {
+    const { answer, mode, accept, decline, beacon } = useContext(ReportingContext);
+    if (mode !== 'consented' || answer !== null || !beacon)
+        return null;
+    return (_jsxs("section", { "data-reporting-consent": "", className: props.className, "aria-label": "Analytics consent", children: [props.children, _jsxs("div", { "data-reporting-consent-actions": "", children: [_jsx("button", { type: "button", "data-reporting-consent-decline": "", onClick: decline, children: props.declineLabel ?? 'No thanks' }), _jsx("button", { type: "button", "data-reporting-consent-accept": "", onClick: accept, children: props.acceptLabel ?? 'Allow' })] })] }));
+}

package/dist/schema.d.ts

@@ -28,9 +28,16 @@ export declare const LIMITS: {
     readonly dataBytes: 16384;
     readonly site: 64;
 };
-/** Flat, bounded, and free of the banned keys. Numbers must be finite: JSON has no NaN. */
+/** Flat, bounded, banned keys refused, numbers finite. */
 export declare const flatDataSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
 export type FlatData = z.infer<typeof flatDataSchema>;
+/**
+ * `z.object`, not strict: a host hands over its resolved principal, which
+ * carries a display name and an address beside `class` and `id`, and those
+ * must be dropped rather than refused. Stripping is the privacy behaviour;
+ * refusing would make every host's call site narrow by hand, and the first
+ * one did not.
+ */
 export declare const actorSchema: z.ZodObject<{
     class: z.ZodEnum<{
         human: "human";
@@ -39,12 +46,12 @@ export declare const actorSchema: z.ZodObject<{
         service: "service";
     }>;
     id: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type Actor = z.infer<typeof actorSchema>;
 export declare const targetSchema: z.ZodObject<{
     type: z.ZodString;
     id: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strip>;
 /** What a caller hands `event()`. Everything else on the row is the writer's. */
 export declare const eventInputSchema: z.ZodObject<{
     kind: z.ZodString;
@@ -64,12 +71,12 @@ export declare const eventInputSchema: z.ZodObject<{
             service: "service";
         }>;
         id: z.ZodString;
-    }, z.core.$strict>>>;
+    }, z.core.$strip>>>;
     requestId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     target: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         type: z.ZodString;
         id: z.ZodString;
-    }, z.core.$strict>>>;
+    }, z.core.$strip>>>;
     data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
     occurredAt: z.ZodOptional<z.ZodDate>;
 }, z.core.$strict>;

package/dist/schema.js

@@ -36,7 +36,7 @@ export const LIMITS = {
     site: 64,
 };
 const scalar = z.union([z.string(), z.number(), z.boolean(), z.null()]);
-/** Flat, bounded, and free of the banned keys. Numbers must be finite: JSON has no NaN. */
+/** Flat, bounded, banned keys refused, numbers finite. */
 export const flatDataSchema = z.record(z.string(), scalar).superRefine((data, ctx) => {
     for (const key of Object.keys(data)) {
         if (BANNED_KEYS.includes(key)) {
@@ -55,11 +55,18 @@ export const flatDataSchema = z.record(z.string(), scalar).superRefine((data, ct
     }
 });
 const bounded = (max) => z.string().min(1).max(max);
-export const actorSchema = z.strictObject({
+/**
+ * `z.object`, not strict: a host hands over its resolved principal, which
+ * carries a display name and an address beside `class` and `id`, and those
+ * must be dropped rather than refused. Stripping is the privacy behaviour;
+ * refusing would make every host's call site narrow by hand, and the first
+ * one did not.
+ */
+export const actorSchema = z.object({
     class: z.enum(ACTOR_CLASSES),
     id: bounded(LIMITS.actorId),
 });
-export const targetSchema = z.strictObject({
+export const targetSchema = z.object({
     type: bounded(LIMITS.targetType),
     id: bounded(LIMITS.targetId),
 });

package/dist/settings.d.ts

@@ -9,7 +9,7 @@ export declare const RETENTION_BOUNDS: {
     readonly min: 7;
     readonly max: 400;
 };
-export declare const SETTING_KEYS: (keyof Settings)[];
+export declare const CONSENT_MODES: readonly ["none", "consented", "always"];
 export declare const DEFAULT_SETTINGS: Settings;
 export declare function getSettings(db: Db): Promise<Settings>;
 /** Validates every key, writes the changed ones in one transaction, returns before and after. Throws on an out-of-bounds value: the caller is a form. */

package/dist/settings.js

@@ -8,16 +8,20 @@ import { reportingSettings } from './tables.js';
  * do is shorten history to a week.
  */
 export const RETENTION_BOUNDS = { min: 7, max: 400 };
+export const CONSENT_MODES = ['none', 'consented', 'always'];
+const retention = z.number().int().min(RETENTION_BOUNDS.min).max(RETENTION_BOUNDS.max);
 const DEFS = {
-    'events.retention_days': {
-        schema: z.number().int().min(RETENTION_BOUNDS.min).max(RETENTION_BOUNDS.max),
-        default: 30,
-    },
+    'events.retention_days': { schema: retention, default: 30 },
+    // Ninety, not thirty: behaviour is watched over years through the rollups,
+    // and a dimension they lack is a recompute over this window (D13).
+    'analytics.retention_days': { schema: retention, default: 90 },
+    // Cookieless until the person says otherwise (D15).
+    'analytics.consent': { schema: z.enum(CONSENT_MODES), default: 'consented' },
+    // A signed-in person's rows carry their id, as the product's own record of
+    // serving them; one line to change if advice changes (D15).
+    'analytics.identify_signed_in': { schema: z.boolean(), default: true },
 };
-export const SETTING_KEYS = Object.keys(DEFS);
-export const DEFAULT_SETTINGS = Object.freeze({
-    'events.retention_days': DEFS['events.retention_days'].default,
-});
+export const DEFAULT_SETTINGS = Object.freeze(Object.fromEntries(Object.entries(DEFS).map(([k, d]) => [k, d.default])));
 function fromRows(rows) {
     const out = { ...DEFAULT_SETTINGS };
     for (const row of rows) {
@@ -45,7 +49,9 @@ export async function setSettings(db, patch, by) {
             throw new Error(`reporting.settings: unknown key "${key}"`);
         const parsed = def.schema.safeParse(value);
         if (!parsed.success) {
-            throw new Error(`reporting.settings: ${key} must be an integer between ${RETENTION_BOUNDS.min} and ${RETENTION_BOUNDS.max}`);
+            throw new Error(key.endsWith('retention_days')
+                ? `reporting.settings: ${key} must be an integer between ${RETENTION_BOUNDS.min} and ${RETENTION_BOUNDS.max}`
+                : `reporting.settings: ${key} is not a valid value`);
         }
     }
     return db.transaction(async (tx) => {