expo-release 2.2.0 → 2.3.0

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.0",
+	"version": "2.3.0",
 	"description": "Fingerprint-driven Expo EAS release: OTA update or native store build, plus app runtime helpers",
 	"type": "module",
 	"module": "./dist/index.js",
@@ -57,6 +57,10 @@
 		"typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.runtime.json",
 		"verify:package": "node scripts/verify-package.mjs"
 	},
+	"dependencies": {
+		"hanzio": "^3.1.0",
+		"zod": "^4.3.6"
+	},
 	"peerDependencies": {
 		"expo-device": ">=55",
 		"expo-notifications": ">=55",

package/src/args.ts

@@ -1,4 +1,5 @@
-import { parseArgs } from 'node:util'
+import type { CommandContext } from 'hanzio/cli'
+import { z } from 'zod'
 
 export const DEFAULT_IMPACT_PATHS = ['apps/expo/'] as const
 
@@ -39,76 +40,133 @@ export type ReleaseOptions = {
 	dryRun: boolean
 }
 
-export const USAGE =
-	'Usage: expo-release <release|decide|operate> --profile <profile> [--base <sha>] [--head <sha>] [--platform ios|android] [--impact-paths apps/expo/] [--operation deploy|force-native|retry-ota|republish|rollback-embedded] [--deploy-type none|ota|native] [--channel <channel>] [--environment <env>] [--group <id>] [--runtime-version <hash>] [--message <msg>] [--fingerprint <hash>] [--auto-submit true] [--export-source-maps true] [--pre-update <cmd>] [--post-update <cmd>] [--update-extra-args <args>] [--dry-run] [--ignore-expo-impact true]'
-
-function fromEnv(env: NodeJS.ProcessEnv, name: string): string | undefined {
-	const value = env[name]?.trim()
-	return value ? value : undefined
-}
-
-function firstDefined(
-	...values: Array<string | undefined>
-): string | undefined {
-	return values.find((value) => value !== undefined && value.length > 0)
-}
-
-export function optionalString(value: string | undefined): string | undefined {
-	const trimmed = value?.trim()
-	return trimmed ? trimmed : undefined
-}
-
-export function parseImpactPaths(value: string | undefined): string[] {
-	const paths = (value ?? DEFAULT_IMPACT_PATHS.join(','))
-		.split(',')
-		.map((path) => path.trim())
-		.filter(Boolean)
-	if (paths.length === 0) {
-		throw new Error('At least one --impact-paths entry is required')
-	}
-	return paths
-}
-
-export function parsePlatform(value: string | undefined): ReleasePlatform {
-	if (value === undefined || value === 'ios') return 'ios'
-	if (value === 'android') return 'android'
-	throw new Error('Usage: --platform ios|android')
-}
-
-export function parseBoolean(value: string | undefined, fallback: boolean) {
-	if (value === undefined) return fallback
-	if (value === 'true') return true
-	if (value === 'false') return false
-	throw new Error(`Expected true or false, received: ${value}`)
-}
-
-export function parseOperation(value: string | undefined): Operation {
-	if (
-		value === undefined ||
-		value === 'deploy' ||
-		value === 'force-native' ||
-		value === 'retry-ota' ||
-		value === 'republish' ||
-		value === 'rollback-embedded'
-	) {
-		return value ?? 'deploy'
-	}
-	throw new Error(
-		'Usage: --operation deploy|force-native|retry-ota|republish|rollback-embedded'
-	)
-}
-
-export function parseDeployType(value: string | undefined): DeployType {
-	if (value === undefined || value === 'none') return 'none'
-	if (value === 'ota' || value === 'native') return value
-	throw new Error('Usage: --deploy-type none|ota|native')
-}
-
-export function parseCommandName(value: string | undefined): CommandName {
-	if (value === 'release' || value === 'decide' || value === 'operate') {
-		return value
+// Every flag falls back to an EXPO_RELEASE_* variable: the composite action passes its inputs that way.
+const text = (env: string) =>
+	z
+		.string()
+		.transform((value) => value.trim() || undefined)
+		.optional()
+		.meta({ env: `EXPO_RELEASE_${env}` })
+
+// `--auto-submit false` takes a value, so these are not boolean switches.
+const trueFalse = (env: string, fallback: 'true' | 'false') =>
+	z
+		.enum(['true', 'false'])
+		.default(fallback)
+		.transform((value) => value === 'true')
+		.meta({ env: `EXPO_RELEASE_${env}` })
+
+export const releaseFlags = z
+	.object({
+		profile: z
+			.string()
+			.trim()
+			.min(1)
+			.meta({ env: 'EXPO_RELEASE_PROFILE' })
+			.describe('EAS build profile, also the default update channel'),
+		base: text('BASE').describe(
+			'Git base SHA for the impact diff (falls back to GITHUB_EVENT_BEFORE)'
+		),
+		head: text('HEAD').describe(
+			'Git head SHA for the impact diff (falls back to GITHUB_SHA)'
+		),
+		platform: z
+			.enum(['ios', 'android'])
+			.default('ios')
+			.meta({ env: 'EXPO_RELEASE_PLATFORM' })
+			.describe('Native platform'),
+		impactPaths: z
+			.string()
+			.default(DEFAULT_IMPACT_PATHS.join(','))
+			.transform((value, ctx) => {
+				const paths = value
+					.split(',')
+					.map((path) => path.trim())
+					.filter(Boolean)
+				if (paths.length === 0)
+					ctx.addIssue({
+						code: 'custom',
+						message: 'At least one --impact-paths entry is required'
+					})
+				return paths
+			})
+			.meta({ env: 'EXPO_RELEASE_IMPACT_PATHS' })
+			.describe('Comma-separated repo-root paths that count as an Expo change'),
+		ignoreExpoImpact: trueFalse('IGNORE_EXPO_IMPACT', 'false').describe(
+			'Check the fingerprint even when no impact path changed'
+		),
+		operation: z
+			.enum([
+				'deploy',
+				'force-native',
+				'retry-ota',
+				'republish',
+				'rollback-embedded'
+			])
+			.default('deploy')
+			.meta({ env: 'EXPO_RELEASE_OPERATION' })
+			.describe('What to run'),
+		deployType: z
+			.enum(['none', 'ota', 'native'])
+			.default('none')
+			.meta({ env: 'EXPO_RELEASE_DEPLOY_TYPE' })
+			.describe('Decision type for operate'),
+		channel: text('CHANNEL').describe(
+			'EAS Update channel (default: the profile)'
+		),
+		environment: text('ENVIRONMENT').describe(
+			'EAS environment for eas update (required for Expo SDK 55+)'
+		),
+		autoSubmit: trueFalse('AUTO_SUBMIT', 'true').describe(
+			'Pass --auto-submit on native builds'
+		),
+		preUpdate: text('PRE_UPDATE').describe(
+			'Shell command run before eas update'
+		),
+		postUpdate: text('POST_UPDATE').describe(
+			'Shell command run after a successful eas update'
+		),
+		updateExtraArgs: text('UPDATE_EXTRA_ARGS').describe(
+			'Extra tokens appended to eas update'
+		),
+		exportSourceMaps: trueFalse('EXPORT_SOURCE_MAPS', 'false').describe(
+			'On OTA, expo export with external source maps, then publish dist'
+		),
+		group: text('GROUP').describe('Update group ID for --operation republish'),
+		runtimeVersion: text('RUNTIME_VERSION').describe(
+			'Runtime version for rollback-embedded (default: the fingerprint)'
+		),
+		message: text('MESSAGE').describe('Override the eas update message'),
+		fingerprint: text('FINGERPRINT').describe(
+			'Fingerprint hash to use instead of generating one'
+		),
+		dryRun: z
+			.boolean()
+			.meta({ env: 'EXPO_RELEASE_DRY_RUN' })
+			.describe('Print mutating EAS commands without running them')
+	})
+	.superRefine((flags, ctx) => {
+		if (flags.operation === 'republish' && !flags.group)
+			ctx.addIssue({
+				code: 'custom',
+				path: ['group'],
+				message: 'required by --operation republish'
+			})
+	})
+
+export type ReleaseFlags = z.output<typeof releaseFlags>
+
+export function toReleaseOptions(
+	command: CommandName,
+	{ context: flags, env }: CommandContext<ReleaseFlags>
+): ReleaseOptions {
+	return {
+		...flags,
+		command,
+		base: flags.base ?? env.GITHUB_EVENT_BEFORE,
+		head: flags.head ?? env.GITHUB_SHA,
+		channel: flags.channel ?? flags.profile
 	}
-	throw new Error(USAGE)
 }
 
 export function needsDecide(operation: Operation): boolean {
@@ -137,192 +195,3 @@ export function shouldIgnoreExpoImpact(
 		options.operation === 'deploy'
 	)
 }
-
-export function parseReleaseOptions(
-	args: string[],
-	env: NodeJS.ProcessEnv = process.env
-): ReleaseOptions {
-	let values: {
-		profile?: string
-		base?: string
-		head?: string
-		platform?: string
-		'impact-paths'?: string
-		'ignore-expo-impact'?: string
-		operation?: string
-		'deploy-type'?: string
-		channel?: string
-		environment?: string
-		'auto-submit'?: string
-		'pre-update'?: string
-		'post-update'?: string
-		'update-extra-args'?: string
-		'export-source-maps'?: string
-		group?: string
-		'runtime-version'?: string
-		message?: string
-		fingerprint?: string
-		'dry-run'?: boolean
-	}
-	let positionals: string[]
-
-	try {
-		const parsed = parseArgs({
-			args,
-			allowPositionals: true,
-			strict: true,
-			options: {
-				profile: { type: 'string' },
-				base: { type: 'string' },
-				head: { type: 'string' },
-				platform: { type: 'string' },
-				'impact-paths': { type: 'string' },
-				'ignore-expo-impact': { type: 'string' },
-				operation: { type: 'string' },
-				'deploy-type': { type: 'string' },
-				channel: { type: 'string' },
-				environment: { type: 'string' },
-				'auto-submit': { type: 'string' },
-				'pre-update': { type: 'string' },
-				'post-update': { type: 'string' },
-				'update-extra-args': { type: 'string' },
-				'export-source-maps': { type: 'string' },
-				group: { type: 'string' },
-				'runtime-version': { type: 'string' },
-				message: { type: 'string' },
-				fingerprint: { type: 'string' },
-				'dry-run': { type: 'boolean', default: false }
-			}
-		})
-		values = parsed.values
-		positionals = parsed.positionals
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error)
-		throw new Error(`${USAGE}\n${message}`)
-	}
-
-	if (positionals.length > 1) {
-		throw new Error(USAGE)
-	}
-
-	const command = parseCommandName(
-		positionals[0] ?? fromEnv(env, 'EXPO_RELEASE_COMMAND')
-	)
-	const profile = firstDefined(
-		values.profile,
-		fromEnv(env, 'EXPO_RELEASE_PROFILE')
-	)
-	if (!profile) {
-		throw new Error(USAGE)
-	}
-
-	const operation = parseOperation(
-		firstDefined(values.operation, fromEnv(env, 'EXPO_RELEASE_OPERATION'))
-	)
-	const group = optionalString(
-		firstDefined(values.group, fromEnv(env, 'EXPO_RELEASE_GROUP'))
-	)
-	if (operation === 'republish' && !group) {
-		throw new Error(
-			'Usage: --operation republish requires --group <update-group-id>'
-		)
-	}
-
-	const channel =
-		firstDefined(values.channel, fromEnv(env, 'EXPO_RELEASE_CHANNEL')) ??
-		profile
-
-	return {
-		command,
-		profile,
-		base: optionalString(
-			firstDefined(
-				values.base,
-				fromEnv(env, 'EXPO_RELEASE_BASE'),
-				fromEnv(env, 'GITHUB_EVENT_BEFORE')
-			)
-		),
-		head: optionalString(
-			firstDefined(
-				values.head,
-				fromEnv(env, 'EXPO_RELEASE_HEAD'),
-				fromEnv(env, 'GITHUB_SHA')
-			)
-		),
-		platform: parsePlatform(
-			firstDefined(values.platform, fromEnv(env, 'EXPO_RELEASE_PLATFORM'))
-		),
-		impactPaths: parseImpactPaths(
-			firstDefined(
-				values['impact-paths'],
-				fromEnv(env, 'EXPO_RELEASE_IMPACT_PATHS')
-			)
-		),
-		ignoreExpoImpact: parseBoolean(
-			firstDefined(
-				values['ignore-expo-impact'],
-				fromEnv(env, 'EXPO_RELEASE_IGNORE_EXPO_IMPACT')
-			),
-			false
-		),
-		operation,
-		deployType: parseDeployType(
-			firstDefined(
-				values['deploy-type'],
-				fromEnv(env, 'EXPO_RELEASE_DEPLOY_TYPE')
-			)
-		),
-		channel,
-		environment: optionalString(
-			firstDefined(values.environment, fromEnv(env, 'EXPO_RELEASE_ENVIRONMENT'))
-		),
-		autoSubmit: parseBoolean(
-			firstDefined(
-				values['auto-submit'],
-				fromEnv(env, 'EXPO_RELEASE_AUTO_SUBMIT')
-			),
-			true
-		),
-		preUpdate: optionalString(
-			firstDefined(
-				values['pre-update'],
-				fromEnv(env, 'EXPO_RELEASE_PRE_UPDATE')
-			)
-		),
-		postUpdate: optionalString(
-			firstDefined(
-				values['post-update'],
-				fromEnv(env, 'EXPO_RELEASE_POST_UPDATE')
-			)
-		),
-		updateExtraArgs: optionalString(
-			firstDefined(
-				values['update-extra-args'],
-				fromEnv(env, 'EXPO_RELEASE_UPDATE_EXTRA_ARGS')
-			)
-		),
-		exportSourceMaps: parseBoolean(
-			firstDefined(
-				values['export-source-maps'],
-				fromEnv(env, 'EXPO_RELEASE_EXPORT_SOURCE_MAPS')
-			),
-			false
-		),
-		group,
-		runtimeVersion: optionalString(
-			firstDefined(
-				values['runtime-version'],
-				fromEnv(env, 'EXPO_RELEASE_RUNTIME_VERSION')
-			)
-		),
-		message: optionalString(
-			firstDefined(values.message, fromEnv(env, 'EXPO_RELEASE_MESSAGE'))
-		),
-		fingerprint: optionalString(
-			firstDefined(values.fingerprint, fromEnv(env, 'EXPO_RELEASE_FINGERPRINT'))
-		),
-		dryRun:
-			values['dry-run'] === true ||
-			parseBoolean(fromEnv(env, 'EXPO_RELEASE_DRY_RUN'), false)
-	}
-}