@chipmobilesdk/rn-notification 0.4.0 → 0.5.0

package/src/state/mmkv-store.ts

@@ -1,75 +1,92 @@
-/**
- * MMKV-backed state store.
- *
- * Every MMKV import is confined to this file, so the rest of the package stays
- * testable without a native module.
- *
- * Backup exclusion is achieved by *where* the data lives rather than by setting
- * a file attribute: on iOS the instance is rooted under `Library/Caches`, which
- * the platform excludes from iCloud and iTunes backup by design. The OS may
- * purge that directory under storage pressure — acceptable here precisely
- * because discarding and rebuilding this record is already a specified,
- * non-blocking condition.
- *
- * On Android, backup exclusion is declared in the consuming app's
- * `data_extraction_rules.xml` and `full_backup_content`, documented in the
- * README. It is the app's manifest, so it is the app's declaration to make.
- */
-
-import { Platform } from 'react-native';
-import type { StateStore } from './store';
-import { createMemoryStore } from './store';
-
-const INSTANCE_ID = 'chipmobilesdk.notification';
-
-/** The slice of a react-native-mmkv v4 instance this store uses (v4 names). */
-interface MmkvLike {
-	getString(key: string): string | undefined;
-	set(key: string, value: string): void;
-	remove(key: string): unknown;
-	clearAll(): void;
-	getAllKeys(): string[];
-}
-
-/**
- * Creates the persistent store, falling back to memory when MMKV is absent.
- *
- * The fallback is deliberate: a missing optional native module degrades
- * deduplication and cold-start buffering to session scope, which is a
- * documented degradation. It must never stop notifications being delivered.
- */
-export function createMmkvStore(): StateStore {
-	let instance: MmkvLike;
-
-	try {
-		// Required lazily so the package loads in environments without the native module.
-		// v4's factory: up to 0.2.0 this called the v3 `new MMKV()`, which v4 — the
-		// only major the peer range allows — no longer exports as a value, so every
-		// device silently got the session-scoped memory store.
-		const { createMMKV } = require('react-native-mmkv') as {
-			createMMKV: (config: { id: string; path?: string }) => MmkvLike;
-		};
-
-		instance = createMMKV({
-			id: INSTANCE_ID,
-			// Caches is backup-excluded by platform design; see the note above.
-			path: Platform.OS === 'ios' ? 'Library/Caches/chipmobilesdk-notification' : undefined,
-		});
-	} catch {
-		return createMemoryStore();
-	}
-
-	return {
-		getString: key => instance.getString(key),
-		setString: (key, value) => instance.set(key, value),
-		delete: key => instance.remove(key),
-		clearAll: () => instance.clearAll(),
-		approximateBytes: () => {
-			let total = 0;
-			for (const key of instance.getAllKeys()) {
-				total += key.length + (instance.getString(key)?.length ?? 0);
-			}
-			return total;
-		},
-	};
-}
+/**
+ * MMKV-backed state store.
+ *
+ * Every MMKV import is confined to this file, so the rest of the package stays
+ * testable without a native module.
+ *
+ * Backup exclusion is achieved by *where* the data lives rather than by setting
+ * a file attribute: on iOS the instance is rooted under `Library/Caches`, which
+ * the platform excludes from iCloud and iTunes backup by design. The OS may
+ * purge that directory under storage pressure — acceptable here precisely
+ * because discarding and rebuilding this record is already a specified,
+ * non-blocking condition.
+ *
+ * On Android, backup exclusion is declared in the consuming app's
+ * `data_extraction_rules.xml` and `full_backup_content`, documented in the
+ * README. It is the app's manifest, so it is the app's declaration to make.
+ */
+
+import {
+	createDiagnosticChannel,
+	currentPlatform,
+	lazyPeer,
+	openDurable,
+	type MmkvLike,
+} from '@chipmobilesdk/rn-core';
+
+import { DIAGNOSTIC_CODES } from '../contract/errors';
+import type { StateStore } from './store';
+
+const INSTANCE_ID = 'chipmobilesdk.notification';
+
+const mmkv = lazyPeer('react-native-mmkv', () => {
+	// Inside `try`, so Metro bundles an app that leaves this optional peer out.
+	try {
+		return require('react-native-mmkv') as {
+			createMMKV: (config: { id: string; path?: string }) => MmkvLike;
+		};
+	} catch (cause) {
+		throw cause;
+	}
+});
+
+const channel = createDiagnosticChannel('rn-notification');
+
+export interface MmkvStoreOptions {
+	/** Told once, with the reason, when the store falls back to memory. */
+	readonly onDegraded?: (cause: unknown) => void;
+}
+
+/**
+ * Creates the persistent store, falling back to memory when MMKV is absent.
+ *
+ * The fallback is deliberate: a missing optional native module degrades
+ * deduplication and cold-start buffering to session scope, which is a
+ * documented degradation. It must never stop notifications being delivered, and
+ * it is never silent (NOT-15): it reports `STATE_STORE_DEGRADED` to the app's SDK
+ * sinks and to `onDegraded`, and the store reports `durable: false`.
+ */
+export function createMmkvStore(options: MmkvStoreOptions = {}): StateStore {
+	const port = openDurable(
+		() =>
+			// v4's factory: up to 0.2.0 this called the v3 `new MMKV()`, which v4 no
+			// longer exports as a value, so every device silently got memory.
+			mmkv
+				.require(peer => new Error(`${peer} is not installed`))
+				.createMMKV({
+					id: INSTANCE_ID,
+					// Caches is backup-excluded by platform design; see the note above.
+					...(currentPlatform() === 'ios'
+						? { path: 'Library/Caches/chipmobilesdk-notification' }
+						: {}),
+				}),
+		cause => {
+			channel.emit(DIAGNOSTIC_CODES.STATE_STORE_DEGRADED, 'warn');
+			options.onDegraded?.(cause);
+		},
+	);
+	return {
+		getString: key => port.getString(key),
+		setString: (key, value) => port.set(key, value),
+		delete: key => port.remove(key),
+		clearAll: () => port.clearAll(),
+		approximateBytes: () => {
+			let total = 0;
+			for (const key of port.keys()) {
+				total += key.length + (port.getString(key)?.length ?? 0);
+			}
+			return total;
+		},
+		durable: port.durable,
+	};
+}

package/src/state/permission-history.ts

@@ -1,41 +1,41 @@
-/**
- * Permission-request history.
- *
- * The platform cannot tell you whether you have already asked. On both
- * platforms a second request after a denial is silently a no-op, so an app that
- * does not remember will keep "asking" and keep appearing to be refused.
- *
- * Keyed by owner tag so a multi-account device can clear one account's history
- * on sign-out without forgetting what it asked the others.
- */
-
-import type { StateManager } from './record';
-import type { PermissionKind } from '../contract/permission';
-
-function key(kind: PermissionKind, ownerTag?: string): string {
-	return `${ownerTag ?? '*'}:${kind}`;
-}
-
-export function hasRequested(
-	state: StateManager,
-	kind: PermissionKind,
-	ownerTag?: string,
-): boolean {
-	const target = key(kind, ownerTag);
-	return state.read().permissionHistory.some(entry => entry.key === target && entry.requested);
-}
-
-export function recordRequested(
-	state: StateManager,
-	kind: PermissionKind,
-	now: number,
-	ownerTag?: string,
-): void {
-	const target = key(kind, ownerTag);
-	if (hasRequested(state, kind, ownerTag)) return;
-
-	state.update('permissionHistory', current => [
-		...current.filter(entry => entry.key !== target),
-		{ at: now, key: target, requested: true },
-	]);
-}
+/**
+ * Permission-request history.
+ *
+ * The platform cannot tell you whether you have already asked. On both
+ * platforms a second request after a denial is silently a no-op, so an app that
+ * does not remember will keep "asking" and keep appearing to be refused.
+ *
+ * Keyed by owner tag so a multi-account device can clear one account's history
+ * on sign-out without forgetting what it asked the others.
+ */
+
+import type { StateManager } from './record';
+import type { PermissionKind } from '../contract/permission';
+
+function key(kind: PermissionKind, ownerTag?: string): string {
+	return `${ownerTag ?? '*'}:${kind}`;
+}
+
+export function hasRequested(
+	state: StateManager,
+	kind: PermissionKind,
+	ownerTag?: string,
+): boolean {
+	const target = key(kind, ownerTag);
+	return state.read().permissionHistory.some(entry => entry.key === target && entry.requested);
+}
+
+export function recordRequested(
+	state: StateManager,
+	kind: PermissionKind,
+	now: number,
+	ownerTag?: string,
+): void {
+	const target = key(kind, ownerTag);
+	if (hasRequested(state, kind, ownerTag)) return;
+
+	state.update('permissionHistory', current => [
+		...current.filter(entry => entry.key !== target),
+		{ at: now, key: target, requested: true },
+	]);
+}