expo-release 2.2.1 → 2.3.1

package/README.md

@@ -492,12 +492,30 @@ export const push = createPushNotifications({
 | Member | Use |
 |--------|-----|
 | `prompt()` | After sign-in. Asks once per install (soft-ask, then OS dialog), registers the token on a grant. Never throws; concurrent calls share one dialog. |
-| `enable()` / `disable()` | Settings toggle. `enable` requests permission and registers; `disable` calls `registerDevice(null)`. Save the user's preference yourself, before `enable()`: a denied dialog then leaves the preference on with `isEnabled` false, and the token registers on the next mount once permission is granted in device settings. |
-| `syncToken()` | Re-registers the current token when permission is granted. |
-| `listen({ onReceived, onResponse })` | Subscribes and returns the unsubscribe function. `onResponse` also receives the tap that launched the app. |
+| `enable()` / `disable()` | Settings toggle. `enable` requests permission and registers; `disable` calls `registerDevice(null)`. Use `disable()` to turn push off (also on sign-out) so the token is not re-sent on the next launch. |
+| `syncToken()` | Registers the current token when permission is granted. |
+| `listen({ onReceived, onResponse })` | Subscribes and returns the unsubscribe function. `onResponse` also receives the tap that launched the app. Also keeps the token current: on start and whenever Expo rotates it, a token that differs from the last one sent is registered again. This runs only after a token was sent and `disable()` has not run since. Call it once at the root of the app. |
 | `getPermissionStatus()`, `getPushToken()`, `requestPermissions()`, `hasPrompted()` | Lower-level steps. |
 
-`usePushNotifications(push, { enabled })` gives a settings screen `permission`, `isEnabled`, `isLoading` and wrapped `prompt`/`enable`/`disable`. `enabled` is the saved preference; while it is on, the token is re-registered on mount.
+`usePushNotifications(push, { enabled, persist })` gives a settings screen `permission`, `isEnabled`, `isLoading` and wrapped `prompt`/`enable`/`disable`. `enabled` is the saved preference; while it is on, the token is re-registered on mount.
+
+`persist` saves the preference, for example on the user's account. `enable()` and `disable()` call it first and show the new value right away. If it rejects, the hook restores `enabled`, skips the push step and rethrows, so catch it for your error toast. Saving before `enable()` means a denied dialog leaves the preference on with `isEnabled` false; the token registers on the next mount once permission is granted in device settings. Without `persist`, save the preference yourself before calling `enable()`.
+
+```tsx
+const { isEnabled, isLoading, enable, disable } = usePushNotifications(push, {
+  enabled: user.pushEnabled,
+  persist: (pushEnabled) => api.user.update({ pushEnabled })
+})
+
+const onToggle = async (on: boolean) => {
+  try {
+    if (!on) return await disable()
+    if (!(await enable())) toast('Allow notifications in device settings')
+  } catch {
+    toast('Could not save your notification setting')
+  }
+}
+```
 
 ### Error boundary
 
@@ -522,9 +540,9 @@ Composite actions for Bun monorepos, used as `HansKristoffer/expo-release/.githu
 
 | Action | Does |
 |--------|------|
-| `setup-workspace` | Bun (version from `package.json` `packageManager` by default), optional Node, restore the dependency cache keyed on `bun.lock`, always `bun install --frozen-lockfile`, save on a miss with `save-cache: 'true'`. `cache-paths` and `cache-key-files` are inputs. |
-| `playwright-browsers` | Restores browsers for the installed Playwright version; installs and saves on a miss. |
-| `pr-preview` | Railway preview environment per PR with its own PlanetScale Postgres branch and a Cloudflare-managed host. Creates on open/sync, deletes on close. |
+| `setup-workspace` | Bun (version from `package.json` `packageManager` by default), optional Node, restore the dependency cache keyed on `bun.lock`, always `bun install --frozen-lockfile`, save on a miss with `save-cache: 'true'`. `cache-paths` and `cache-key-files` are inputs. On a self-hosted runner it keeps `cache-paths` instead (see below). |
+| `playwright-browsers` | Restores browsers for the installed Playwright version; installs and saves on a miss. A self-hosted runner skips the cache and keeps `~/.cache/ms-playwright`. |
+| `pr-preview` | Railway preview environment per PR with its own PlanetScale Postgres branch and a Cloudflare-managed host. Creates on open/sync, deletes on close. The Railway CLI goes into the job's `$RUNNER_TEMP`. |
 | `ai-changelog` | Plain-language changelog of a pushed range with Claude; outputs `message` (chat) and `markdown`, optionally POSTs the message to a webhook. |
 
 ### Warm the caches on main
@@ -562,6 +580,29 @@ jobs:
 
 Use the same `cache-paths` in every job, since they are part of the cache version.
 
+### Self-hosted runners
+
+A self-hosted runner keeps its workspace between jobs, so these actions keep what a hosted VM would restore. Check out with `clean: false`; `setup-workspace` then removes every untracked file except `cache-paths` and `keep-paths`, skips the cache, and skips `bun install` when the files named by `install-key-paths` and the Bun version are unchanged since that runner's last install. Add the files a postinstall reads:
+
+```yaml
+      - uses: actions/checkout@v5
+        with:
+          clean: false
+      - uses: HansKristoffer/expo-release/.github/actions/setup-workspace@v2
+        with:
+          cache-paths: |
+            node_modules
+            packages/*/node_modules
+            apps/*/node_modules
+            packages/prisma/generated
+          keep-paths: .buncargo/typecheck-timings.json
+          install-key-paths: |
+            bun.lock
+            *package.json
+            patches
+            packages/prisma/schema
+```
+
 ### PR preview environments
 
 The preview duplicates `railway-source-environment` (default `staging`) into `pr-<number>`, points git-connected services at the PR branch, sets `DATABASE_URL` and `DATABASE_URL_DIRECT` to a fresh PlanetScale branch, attaches `pr-<number>.<zone>` with Cloudflare DNS, then sets `BASE_URL`, which triggers the one deployment (run migrations and seeds in your pre-deploy step).

package/dist/runtime/index.d.ts

@@ -1,3 +1,3 @@
 export { ErrorBoundary, type ErrorBoundaryFallbackProps, type ErrorBoundaryProps } from './error-boundary';
 export { checkForOTAUpdate, type ReloadApp, type UseOTAUpdatesOptions, useOTAUpdates } from './ota';
-export { createPushNotifications, type KeyValueStorage, type NotificationListeners, type PushNotifications, type PushNotificationsOptions, usePushNotifications } from './push';
+export { createPushNotifications, type KeyValueStorage, type NotificationListeners, type PushNotifications, type PushNotificationsOptions, type UsePushNotificationsOptions, usePushNotifications } from './push';

package/dist/runtime/index.js

@@ -57,7 +57,8 @@ function createPushNotifications(options) {
     onUnavailable,
     onError = (message, error) => console.error(message, error),
     projectId,
-    storageKey = "@notifications_permission_asked"
+    storageKey = "@notifications_permission_asked",
+    tokenStorageKey = "@notifications_push_token"
   } = options;
   Notifications.setNotificationHandler({
     handleNotification: async () => options.foregroundBehavior ?? {
@@ -74,13 +75,23 @@ function createPushNotifications(options) {
   }).catch((error) => onError("Failed to create the notification channel", error));
   let pendingPrompt = null;
   const getPermissionStatus = () => Notifications.getPermissionsAsync();
-  async function hasPrompted() {
+  async function read(key) {
     try {
-      return await storage.getItem(storageKey) === "true";
+      return await storage.getItem(key);
     } catch {
-      return false;
+      return null;
+    }
+  }
+  async function rememberToken(token) {
+    try {
+      await storage.setItem(tokenStorageKey, token);
+    } catch (error) {
+      onError("Failed to remember the push token", error);
     }
   }
+  async function hasPrompted() {
+    return await read(storageKey) === "true";
+  }
   async function requestPermissions() {
     if (!Device.isDevice) {
       onUnavailable?.("not-a-device");
@@ -96,30 +107,40 @@ function createPushNotifications(options) {
       return false;
     }
   }
-  async function getPushToken() {
+  async function getPushToken(devicePushToken) {
     if (!Device.isDevice)
       return null;
     try {
-      const token = await Notifications.getExpoPushTokenAsync(projectId ? { projectId } : undefined);
+      const token = await Notifications.getExpoPushTokenAsync(projectId || devicePushToken ? { projectId, devicePushToken } : undefined);
       return token.data;
     } catch (error) {
       onError("Failed to get the Expo push token", error);
       return null;
     }
   }
-  async function syncToken() {
-    if (!(await getPermissionStatus()).granted)
-      return false;
-    const token = await getPushToken();
-    if (!token)
-      return false;
+  async function sendToken(token) {
     try {
       await registerDevice(token);
-      return true;
     } catch (error) {
       onError("Failed to register the push token", error);
       return false;
     }
+    await rememberToken(token);
+    return true;
+  }
+  async function syncToken() {
+    if (!(await getPermissionStatus()).granted)
+      return false;
+    const token = await getPushToken();
+    return token ? sendToken(token) : false;
+  }
+  async function refreshToken(devicePushToken) {
+    const sent = await read(tokenStorageKey);
+    if (!sent || !(await getPermissionStatus()).granted)
+      return;
+    const token = await getPushToken(devicePushToken);
+    if (token && token !== sent)
+      await sendToken(token);
   }
   async function runPrompt() {
     if (await hasPrompted())
@@ -157,11 +178,15 @@ function createPushNotifications(options) {
       await syncToken();
       return true;
     },
-    disable() {
-      return registerDevice(null);
+    async disable() {
+      await registerDevice(null);
+      await rememberToken("");
     },
-    listen({ onReceived, onResponse }) {
+    listen({ onReceived, onResponse } = {}) {
+      const refresh = (devicePushToken) => refreshToken(devicePushToken).catch((error) => onError("Failed to refresh the push token", error));
+      refresh();
       const subscriptions = [
+        Notifications.addPushTokenListener(refresh),
         onReceived && Notifications.addNotificationReceivedListener(onReceived),
         onResponse && Notifications.addNotificationResponseReceivedListener(onResponse)
       ];
@@ -175,17 +200,31 @@ function createPushNotifications(options) {
     }
   };
 }
-function usePushNotifications(push, { enabled = false } = {}) {
+function usePushNotifications(push, { enabled = false, persist } = {}) {
   const [permission, setPermission] = useState(null);
   const [isLoading, setIsLoading] = useState(false);
+  const [optimistic, setOptimistic] = useState(null);
+  const preference = optimistic ?? enabled;
   const refresh = useCallback(async () => {
     setPermission(await push.getPermissionStatus());
   }, [push]);
   useEffect2(() => {
+    setOptimistic(null);
     refresh();
     if (enabled)
       push.syncToken();
   }, [push, enabled, refresh]);
+  const save = useCallback(async (next) => {
+    if (!persist)
+      return;
+    setOptimistic(next);
+    try {
+      await persist(next);
+    } catch (error) {
+      setOptimistic(null);
+      throw error;
+    }
+  }, [persist]);
   const withLoading = useCallback((action) => async () => {
     setIsLoading(true);
     try {
@@ -197,11 +236,17 @@ function usePushNotifications(push, { enabled = false } = {}) {
   }, [refresh]);
   return {
     permission,
-    isEnabled: enabled && permission?.granted === true,
+    isEnabled: preference && permission?.granted === true,
     isLoading,
     prompt: withLoading(push.prompt),
-    enable: withLoading(push.enable),
-    disable: withLoading(push.disable),
+    enable: withLoading(async () => {
+      await save(true);
+      return push.enable();
+    }),
+    disable: withLoading(async () => {
+      await save(false);
+      await push.disable();
+    }),
     refresh
   };
 }

package/dist/runtime/push.d.ts

@@ -5,7 +5,7 @@ export interface KeyValueStorage {
     setItem(key: string, value: string): Promise<void>;
 }
 export interface PushNotificationsOptions {
-    /** Remembers that the one-time prompt ran. */
+    /** Remembers that the one-time prompt ran and the last token sent. */
     storage: KeyValueStorage;
     /** Saves this device's Expo push token on your backend; `null` removes it. */
     registerDevice: (token: string | null) => Promise<void>;
@@ -24,6 +24,8 @@ export interface PushNotificationsOptions {
     /** How notifications show while the app is in the foreground. */
     foregroundBehavior?: Notifications.NotificationBehavior;
     storageKey?: string;
+    /** Holds the last token passed to `registerDevice`. */
+    tokenStorageKey?: string;
 }
 export interface NotificationListeners {
     onReceived?: (notification: Notifications.Notification) => void;
@@ -39,7 +41,7 @@ export declare function createPushNotifications(options: PushNotificationsOption
     getPermissionStatus: () => Promise<Notifications.NotificationPermissionsStatus>;
     hasPrompted: () => Promise<boolean>;
     requestPermissions: () => Promise<boolean>;
-    getPushToken: () => Promise<string | null>;
+    getPushToken: (devicePushToken?: Notifications.DevicePushToken) => Promise<string | null>;
     syncToken: () => Promise<boolean>;
     /**
      * Asks for push once per install (after sign-in, say), then registers the
@@ -50,16 +52,26 @@ export declare function createPushNotifications(options: PushNotificationsOption
     enable(): Promise<boolean>;
     /** Removes this device's token from your backend. */
     disable(): Promise<void>;
-    /** Subscribes to notifications. Returns the unsubscribe function. */
-    listen({ onReceived, onResponse }: NotificationListeners): () => void;
+    /**
+     * Subscribes to notifications and keeps the registered token current: on
+     * start and whenever Expo rotates it. Returns the unsubscribe function.
+     */
+    listen({ onReceived, onResponse }?: NotificationListeners): () => void;
 };
+export interface UsePushNotificationsOptions {
+    /** The user's saved preference, for example from your API. */
+    enabled?: boolean;
+    /**
+     * Saves the preference. `enable()` and `disable()` call it first and show
+     * the new value at once; when it rejects, they roll back and rethrow.
+     */
+    persist?: (enabled: boolean) => Promise<unknown>;
+}
 /**
  * Push state for a settings screen. `enabled` is the user's saved preference;
  * while it is on, the token is re-registered on mount.
  */
-export declare function usePushNotifications(push: PushNotifications, { enabled }?: {
-    enabled?: boolean;
-}): {
+export declare function usePushNotifications(push: PushNotifications, { enabled, persist }?: UsePushNotificationsOptions): {
     permission: Notifications.NotificationPermissionsStatus | null;
     isEnabled: boolean;
     isLoading: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "expo-release",
-	"version": "2.2.1",
+	"version": "2.3.1",
 	"description": "Fingerprint-driven Expo EAS release: OTA update or native store build, plus app runtime helpers",
 	"type": "module",
 	"module": "./dist/index.js",

package/src/runtime/index.ts

@@ -15,5 +15,6 @@ export {
 	type NotificationListeners,
 	type PushNotifications,
 	type PushNotificationsOptions,
+	type UsePushNotificationsOptions,
 	usePushNotifications
 } from './push'

package/src/runtime/push.ts

@@ -9,7 +9,7 @@ export interface KeyValueStorage {
 }
 
 export interface PushNotificationsOptions {
-	/** Remembers that the one-time prompt ran. */
+	/** Remembers that the one-time prompt ran and the last token sent. */
 	storage: KeyValueStorage
 	/** Saves this device's Expo push token on your backend; `null` removes it. */
 	registerDevice: (token: string | null) => Promise<void>
@@ -28,6 +28,8 @@ export interface PushNotificationsOptions {
 	/** How notifications show while the app is in the foreground. */
 	foregroundBehavior?: Notifications.NotificationBehavior
 	storageKey?: string
+	/** Holds the last token passed to `registerDevice`. */
+	tokenStorageKey?: string
 }
 
 export interface NotificationListeners {
@@ -50,7 +52,8 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 		onUnavailable,
 		onError = (message, error) => console.error(message, error),
 		projectId,
-		storageKey = '@notifications_permission_asked'
+		storageKey = '@notifications_permission_asked',
+		tokenStorageKey = '@notifications_push_token'
 	} = options
 
 	Notifications.setNotificationHandler({
@@ -78,14 +81,26 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 
 	const getPermissionStatus = () => Notifications.getPermissionsAsync()
 
-	async function hasPrompted() {
+	async function read(key: string) {
 		try {
-			return (await storage.getItem(storageKey)) === 'true'
+			return await storage.getItem(key)
 		} catch {
-			return false
+			return null
+		}
+	}
+
+	async function rememberToken(token: string) {
+		try {
+			await storage.setItem(tokenStorageKey, token)
+		} catch (error) {
+			onError('Failed to remember the push token', error)
 		}
 	}
 
+	async function hasPrompted() {
+		return (await read(storageKey)) === 'true'
+	}
+
 	/** Shows the OS dialog when it still can. Resolves whether push is allowed. */
 	async function requestPermissions() {
 		if (!Device.isDevice) {
@@ -102,11 +117,13 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 		}
 	}
 
-	async function getPushToken() {
+	async function getPushToken(devicePushToken?: Notifications.DevicePushToken) {
 		if (!Device.isDevice) return null
 		try {
 			const token = await Notifications.getExpoPushTokenAsync(
-				projectId ? { projectId } : undefined
+				projectId || devicePushToken
+					? { projectId, devicePushToken }
+					: undefined
 			)
 			return token.data
 		} catch (error) {
@@ -115,18 +132,33 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 		}
 	}
 
-	/** Registers the current token. Resolves whether one was registered. */
-	async function syncToken() {
-		if (!(await getPermissionStatus()).granted) return false
-		const token = await getPushToken()
-		if (!token) return false
+	async function sendToken(token: string) {
 		try {
 			await registerDevice(token)
-			return true
 		} catch (error) {
 			onError('Failed to register the push token', error)
 			return false
 		}
+		await rememberToken(token)
+		return true
+	}
+
+	/** Registers the current token. Resolves whether one was registered. */
+	async function syncToken() {
+		if (!(await getPermissionStatus()).granted) return false
+		const token = await getPushToken()
+		return token ? sendToken(token) : false
+	}
+
+	/**
+	 * Re-registers a token that changed since it was last sent. Runs only while
+	 * push is on for this device: a token was sent and `disable()` has not run.
+	 */
+	async function refreshToken(devicePushToken?: Notifications.DevicePushToken) {
+		const sent = await read(tokenStorageKey)
+		if (!sent || !(await getPermissionStatus()).granted) return
+		const token = await getPushToken(devicePushToken)
+		if (token && token !== sent) await sendToken(token)
 	}
 
 	async function runPrompt() {
@@ -174,13 +206,24 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 		},
 
 		/** Removes this device's token from your backend. */
-		disable() {
-			return registerDevice(null)
+		async disable() {
+			await registerDevice(null)
+			// KeyValueStorage has no removeItem; an empty token means none was sent.
+			await rememberToken('')
 		},
 
-		/** Subscribes to notifications. Returns the unsubscribe function. */
-		listen({ onReceived, onResponse }: NotificationListeners) {
+		/**
+		 * Subscribes to notifications and keeps the registered token current: on
+		 * start and whenever Expo rotates it. Returns the unsubscribe function.
+		 */
+		listen({ onReceived, onResponse }: NotificationListeners = {}) {
+			const refresh = (devicePushToken?: Notifications.DevicePushToken) =>
+				refreshToken(devicePushToken).catch((error: unknown) =>
+					onError('Failed to refresh the push token', error)
+				)
+			void refresh()
 			const subscriptions = [
+				Notifications.addPushTokenListener(refresh),
 				onReceived && Notifications.addNotificationReceivedListener(onReceived),
 				onResponse &&
 					Notifications.addNotificationResponseReceivedListener(onResponse)
@@ -196,27 +239,55 @@ export function createPushNotifications(options: PushNotificationsOptions) {
 	}
 }
 
+export interface UsePushNotificationsOptions {
+	/** The user's saved preference, for example from your API. */
+	enabled?: boolean
+	/**
+	 * Saves the preference. `enable()` and `disable()` call it first and show
+	 * the new value at once; when it rejects, they roll back and rethrow.
+	 */
+	persist?: (enabled: boolean) => Promise<unknown>
+}
+
 /**
  * Push state for a settings screen. `enabled` is the user's saved preference;
  * while it is on, the token is re-registered on mount.
  */
 export function usePushNotifications(
 	push: PushNotifications,
-	{ enabled = false }: { enabled?: boolean } = {}
+	{ enabled = false, persist }: UsePushNotificationsOptions = {}
 ) {
 	const [permission, setPermission] =
 		useState<Notifications.NotificationPermissionsStatus | null>(null)
 	const [isLoading, setIsLoading] = useState(false)
+	// Set by enable/disable until `enabled` catches up with the saved value.
+	const [optimistic, setOptimistic] = useState<boolean | null>(null)
+	const preference = optimistic ?? enabled
 
 	const refresh = useCallback(async () => {
 		setPermission(await push.getPermissionStatus())
 	}, [push])
 
 	useEffect(() => {
+		setOptimistic(null)
 		void refresh()
 		if (enabled) void push.syncToken()
 	}, [push, enabled, refresh])
 
+	const save = useCallback(
+		async (next: boolean) => {
+			if (!persist) return
+			setOptimistic(next)
+			try {
+				await persist(next)
+			} catch (error) {
+				setOptimistic(null)
+				throw error
+			}
+		},
+		[persist]
+	)
+
 	const withLoading = useCallback(
 		<T>(action: () => Promise<T>) =>
 			async () => {
@@ -233,11 +304,17 @@ export function usePushNotifications(
 
 	return {
 		permission,
-		isEnabled: enabled && permission?.granted === true,
+		isEnabled: preference && permission?.granted === true,
 		isLoading,
 		prompt: withLoading(push.prompt),
-		enable: withLoading(push.enable),
-		disable: withLoading(push.disable),
+		enable: withLoading(async () => {
+			await save(true)
+			return push.enable()
+		}),
+		disable: withLoading(async () => {
+			await save(false)
+			await push.disable()
+		}),
 		refresh
 	}
 }