@ramonclaudio/create-vexpo 0.1.0

package/dist/templates/default/lib/auth-client.ts

@@ -0,0 +1,21 @@
+import { expoClient } from "@better-auth/expo/client";
+import { convexClient } from "@convex-dev/better-auth/client/plugins";
+import { createAuthClient } from "better-auth/react";
+import { emailOTPClient, usernameClient } from "better-auth/client/plugins";
+import Constants from "expo-constants";
+import * as SecureStore from "expo-secure-store";
+
+import { env } from "./env";
+
+const rawScheme = Constants.expoConfig?.scheme;
+const scheme = Array.isArray(rawScheme) ? rawScheme[0] : rawScheme;
+
+export const authClient = createAuthClient({
+  baseURL: env.convexSiteUrl,
+  plugins: [
+    convexClient(),
+    usernameClient(),
+    emailOTPClient(),
+    expoClient({ scheme, storagePrefix: scheme ?? "better-auth", storage: SecureStore }),
+  ],
+});

package/dist/templates/default/lib/convex-auth.tsx

@@ -0,0 +1,79 @@
+import { ConvexProviderWithAuth, type ConvexReactClient } from "convex/react";
+import { useCallback, useMemo, useRef, type ReactNode } from "react";
+
+import { authClient } from "./auth-client";
+
+/**
+ * Custom Better Auth → Convex bridge.
+ *
+ * Replaces `ConvexBetterAuthProvider` from `@convex-dev/better-auth/react`,
+ * which has two bugs that prevent Convex from authenticating on Expo:
+ *
+ *  1. `fetchAccessToken` is wrapped in `useCallback(..., [sessionId])`. The
+ *     server-side session id rotates on every `/convex/token` call, so the
+ *     fetcher's identity changes on every render. `ConvexProviderWithAuth`'s
+ *     effect depends on that identity; when it changes it runs the cleanup,
+ *     which sets `isConvexAuthenticated` back to null/false. The next render
+ *     calls `setAuth` again and the cycle repeats. `useConvexAuth().isAuthenticated`
+ *     never settles.
+ *  2. `cachedToken` is captured by closure inside a `useMemo` whose factory
+ *     only re-runs when `authClient` changes (never). State updates don't
+ *     reach the inner closure, so the cache is stale.
+ *
+ * This bridge does the minimum the platform actually needs:
+ *  - `isAuthenticated` / `isLoading` come from `authClient.useSession()` directly.
+ *  - `fetchAccessToken` is identity-stable (`useCallback([])`). The Convex
+ *    client caches the JWT internally and re-calls only on expiry/forceRefresh.
+ *  - In-flight calls de-dup via a ref, so multiple consumers can't fire
+ *    parallel `/convex/token` requests.
+ *
+ * The OAuth one-time-token (`?ott=...`) handling in the upstream provider is
+ * a web-only path (`window === undefined` on native), so we don't replicate it.
+ */
+function useBetterAuthForConvex() {
+  const { data: session, isPending } = authClient.useSession();
+  const isAuthenticated = !!session?.session;
+
+  const inflightRef = useRef<Promise<string | null> | null>(null);
+
+  const fetchAccessToken = useCallback(
+    async ({ forceRefreshToken = false }: { forceRefreshToken?: boolean } = {}) => {
+      if (!forceRefreshToken && inflightRef.current) return inflightRef.current;
+
+      const promise = authClient.convex
+        .token({ fetchOptions: { throw: false } })
+        .then(({ data }) => data?.token ?? null)
+        .catch(() => null)
+        .finally(() => {
+          inflightRef.current = null;
+        });
+
+      inflightRef.current = promise;
+      return promise;
+    },
+    [],
+  );
+
+  return useMemo(
+    () => ({
+      isLoading: isPending,
+      isAuthenticated,
+      fetchAccessToken,
+    }),
+    [isPending, isAuthenticated, fetchAccessToken],
+  );
+}
+
+export function BetterAuthConvexProvider({
+  children,
+  client,
+}: {
+  children: ReactNode;
+  client: ConvexReactClient;
+}) {
+  return (
+    <ConvexProviderWithAuth client={client} useAuth={useBetterAuthForConvex}>
+      {children}
+    </ConvexProviderWithAuth>
+  );
+}

package/dist/templates/default/lib/deep-link.ts

@@ -0,0 +1,71 @@
+import { parse, createURL } from "expo-linking";
+
+export const ALLOWED_DEEP_LINK_PATHS = [
+  "/",
+  "/welcome",
+  "/settings",
+  "/about",
+  "/help",
+  "/privacy",
+  "/sign-in",
+  "/sign-up",
+  "/forgot-password",
+  "/reset-password",
+  "/linked",
+] as const;
+
+export function isValidDeepLink(url: string): boolean {
+  if (!url || typeof url !== "string") return false;
+  if (url.includes("..")) return false;
+
+  const { scheme, path } = parse(url);
+  const isRelativePath = url.startsWith("/") && !url.startsWith("//");
+  if (!isRelativePath && !scheme) return false;
+
+  const normalizedPath = "/" + (path ?? "").replace(/^\//, "");
+
+  return ALLOWED_DEEP_LINK_PATHS.some(
+    (allowed) => normalizedPath === allowed || normalizedPath.startsWith(allowed + "/"),
+  );
+}
+
+export type ResolvedDeepLink = {
+  path: string | null;
+  params: Record<string, string>;
+};
+
+/**
+ * Pure helper that parses a deep link URL into `{ path, params }`.
+ *
+ * Returns `path: null` for invalid URLs, disallowed paths, or traversal attempts.
+ * Array query values are joined with commas; nullish values are dropped.
+ * Unit-testable: no React, no side effects.
+ */
+export function resolveDeepLink(url: string): ResolvedDeepLink {
+  const empty: ResolvedDeepLink = { path: null, params: {} };
+  if (!url || typeof url !== "string") return empty;
+
+  let parsed;
+  try {
+    parsed = parse(url);
+  } catch {
+    return empty;
+  }
+
+  if (!isValidDeepLink(url)) return empty;
+
+  const normalizedPath = "/" + (parsed.path ?? "").replace(/^\//, "").replace(/\/+$/, "");
+  const path = normalizedPath === "/" ? "/" : normalizedPath;
+
+  const params: Record<string, string> = {};
+  if (parsed.queryParams) {
+    for (const [key, value] of Object.entries(parsed.queryParams)) {
+      if (value == null) continue;
+      params[key] = Array.isArray(value) ? value.join(",") : value;
+    }
+  }
+
+  return { path, params };
+}
+
+export { createURL };

package/dist/templates/default/lib/dev-menu.ts

@@ -0,0 +1,119 @@
+import * as DevClient from "expo-dev-client";
+import * as SecureStore from "expo-secure-store";
+import * as Clipboard from "expo-clipboard";
+import Constants from "expo-constants";
+import { checkForUpdateAsync } from "expo-updates";
+
+import { authClient } from "@/lib/auth-client";
+import { checkForUpdate } from "@/lib/updates";
+import { setTheme } from "@/hooks/use-theme";
+import { reloadApp } from "./app";
+
+type SessionResponse = { data?: { session?: { id?: string } } | null };
+
+async function copyAuthSessionId() {
+  try {
+    const res = (await authClient.getSession()) as SessionResponse;
+    const id = res?.data?.session?.id;
+    if (!id) {
+      console.log("[DevMenu] No active auth session");
+      return;
+    }
+    await Clipboard.setStringAsync(id);
+    console.log("[DevMenu] Auth session ID copied:", id);
+  } catch (err) {
+    console.log("[DevMenu] Failed to copy session ID:", err);
+  }
+}
+
+function showPublicEnv() {
+  const keys = Object.keys(process.env).filter((k) => k.startsWith("EXPO_PUBLIC_"));
+  const snapshot: Record<string, string | undefined> = {};
+  for (const k of keys) snapshot[k] = process.env[k];
+  console.log("[DevMenu] EXPO_PUBLIC_* env:", snapshot);
+}
+
+function clearLocalStorage() {
+  const ls = (globalThis as { localStorage?: Storage }).localStorage;
+  if (!ls) {
+    console.log("[DevMenu] localStorage unavailable on native");
+    return;
+  }
+  ls.clear();
+  console.log("[DevMenu] localStorage cleared");
+}
+
+/**
+ * Registers custom dev menu items visible when shaking the device.
+ * Call once at app startup. No-op in production builds.
+ */
+export function registerDevMenuItems() {
+  if (!__DEV__) return;
+
+  DevClient.registerDevMenuItems([
+    {
+      name: "Clear Secure Storage",
+      callback: () => {
+        SecureStore.deleteItemAsync("better-auth_session_token").catch(() => {});
+        SecureStore.deleteItemAsync("better-auth_refresh_token").catch(() => {});
+        console.log("[DevMenu] Secure storage cleared");
+      },
+    },
+    {
+      name: "Reset Theme",
+      callback: () => {
+        setTheme("system");
+        console.log("[DevMenu] Theme reset to system");
+      },
+    },
+    {
+      name: "Copy Session ID",
+      callback: () => {
+        Clipboard.setStringAsync(Constants.sessionId);
+        console.log("[DevMenu] Session ID copied:", Constants.sessionId);
+      },
+      shouldCollapse: true,
+    },
+    {
+      name: "Copy Auth Session ID",
+      callback: () => {
+        void copyAuthSessionId();
+      },
+      shouldCollapse: true,
+    },
+    {
+      name: "Check for Updates",
+      callback: () => {
+        checkForUpdate()
+          .then((result) => console.log("[DevMenu] Update check:", result))
+          .catch((err) => console.log("[DevMenu] Update check unavailable:", err.message));
+      },
+    },
+    {
+      name: "Force OTA Update Check",
+      callback: () => {
+        checkForUpdateAsync()
+          .then((result) => console.log("[DevMenu] Forced update check:", result))
+          .catch((err) =>
+            console.log("[DevMenu] Forced update check failed:", err?.message ?? err),
+          );
+      },
+    },
+    {
+      name: "Clear localStorage",
+      callback: clearLocalStorage,
+    },
+    {
+      name: "Show Env",
+      callback: showPublicEnv,
+      shouldCollapse: true,
+    },
+    {
+      name: "Reload App",
+      callback: () => {
+        reloadApp();
+      },
+      shouldCollapse: true,
+    },
+  ]);
+}

package/dist/templates/default/lib/device.ts

@@ -0,0 +1,40 @@
+import Constants, { ExecutionEnvironment } from "expo-constants";
+
+/** Current execution environment: Bare, Standalone, or StoreClient. */
+export const executionEnvironment = Constants.executionEnvironment;
+
+/** Production/release build created with or without EAS Build. */
+export const isStandalone = executionEnvironment === ExecutionEnvironment.Standalone;
+
+/** Running in Expo Go or a development build with expo-dev-client. */
+export const isStoreClient = executionEnvironment === ExecutionEnvironment.StoreClient;
+
+/** True when running in debug mode (__DEV__). */
+export const debugMode = Constants.debugMode;
+
+/** Unique per app session. Changes on every fresh launch. */
+export const sessionId = Constants.sessionId;
+
+/** True if the app is running headless (background task, no UI). */
+export const isHeadless = Constants.isHeadless;
+
+/** Default status bar height in points. Does not account for calls or location tracking. */
+export const statusBarHeight = Constants.statusBarHeight;
+
+/** Runtime version string. Null on web. */
+export const expoRuntimeVersion = Constants.expoRuntimeVersion;
+
+/** Human-readable device name (e.g. "Ramon's iPhone"). */
+export const deviceName = Constants.deviceName;
+
+/** System font names available on this device. */
+export const systemFonts = Constants.systemFonts;
+
+/** EAS config object. Non-null when built with EAS Build. */
+export const easConfig = Constants.easConfig;
+
+/** iOS-specific manifest: buildNumber, model, systemVersion, etc. */
+export const iosManifest = Constants.platform?.ios;
+
+/** Resolves the user agent string a webview would send from this device. */
+export const getWebViewUserAgentAsync = Constants.getWebViewUserAgentAsync;

package/dist/templates/default/lib/dynamic-font.ts

@@ -0,0 +1,49 @@
+import { useCallback } from "react";
+import { useWindowDimensions } from "react-native";
+import { font } from "@expo/ui/swift-ui/modifiers";
+
+type FontParams = Parameters<typeof font>[0];
+type Weight = NonNullable<FontParams["weight"]>;
+type Design = NonNullable<FontParams["design"]>;
+
+const GEIST_BY_WEIGHT: Record<Weight, string> = {
+  ultraLight: "Geist-Thin",
+  thin: "Geist-Thin",
+  light: "Geist-Light",
+  regular: "Geist-Regular",
+  medium: "Geist-Medium",
+  semibold: "Geist-SemiBold",
+  bold: "Geist-Bold",
+  heavy: "Geist-ExtraBold",
+  black: "Geist-Black",
+};
+
+const GEIST_MONO_BY_WEIGHT: Record<Weight, string> = {
+  ultraLight: "GeistMono-Regular",
+  thin: "GeistMono-Regular",
+  light: "GeistMono-Regular",
+  regular: "GeistMono-Regular",
+  medium: "GeistMono-Medium",
+  semibold: "GeistMono-Medium",
+  bold: "GeistMono-Bold",
+  heavy: "GeistMono-Bold",
+  black: "GeistMono-Bold",
+};
+
+function resolveFamily(weight: Weight | undefined, design: Design | undefined): string {
+  const w = weight ?? "regular";
+  if (design === "monospaced") return GEIST_MONO_BY_WEIGHT[w];
+  return GEIST_BY_WEIGHT[w];
+}
+
+export function useDynamicFont() {
+  const { fontScale } = useWindowDimensions();
+  return useCallback(
+    (params: FontParams) => {
+      const family = params.family ?? resolveFamily(params.weight, params.design);
+      const size = params.size != null ? params.size * fontScale : params.size;
+      return font({ ...params, family, size });
+    },
+    [fontScale],
+  );
+}

package/dist/templates/default/lib/env.ts

@@ -0,0 +1,10 @@
+const convexUrl = process.env.EXPO_PUBLIC_CONVEX_URL;
+const convexSiteUrl = process.env.EXPO_PUBLIC_CONVEX_SITE_URL;
+
+if (!convexUrl) throw new Error("Missing required env var: EXPO_PUBLIC_CONVEX_URL");
+if (!convexSiteUrl) throw new Error("Missing required env var: EXPO_PUBLIC_CONVEX_SITE_URL");
+
+export const env = {
+  convexUrl,
+  convexSiteUrl,
+} as const;

package/dist/templates/default/lib/haptics.ts

@@ -0,0 +1,24 @@
+import * as Haptics from "expo-haptics";
+
+import { preferences } from "@/lib/preferences";
+
+export { Haptics };
+
+const gate = (fn: () => Promise<void>) => () => {
+  if (!preferences.hapticsEnabled()) return Promise.resolve();
+  return fn();
+};
+
+export const haptics = {
+  selection: gate(() => Haptics.selectionAsync()),
+
+  light: gate(() => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light)),
+  medium: gate(() => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium)),
+  heavy: gate(() => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Heavy)),
+  rigid: gate(() => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Rigid)),
+  soft: gate(() => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Soft)),
+
+  success: gate(() => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Success)),
+  warning: gate(() => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Warning)),
+  error: gate(() => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Error)),
+};

package/dist/templates/default/lib/notifications.ts

@@ -0,0 +1,276 @@
+import * as Notifications from "expo-notifications";
+import * as Device from "expo-device";
+import * as TaskManager from "expo-task-manager";
+import Constants from "expo-constants";
+
+// ---------------------------------------------------------------------------
+// Background task
+// ---------------------------------------------------------------------------
+
+export const BACKGROUND_NOTIFICATION_TASK = "BACKGROUND_NOTIFICATION";
+
+try {
+  TaskManager.defineTask<Notifications.NotificationTaskPayload>(
+    BACKGROUND_NOTIFICATION_TASK,
+    async ({ data, error }) => {
+      if (error) {
+        console.error("[Notification] Background task error:", error);
+        return;
+      }
+      if (__DEV__) console.log("[Notification] Background payload:", data);
+    },
+  );
+} catch (e) {
+  if (__DEV__) console.warn("[Notification] defineTask failed:", e);
+}
+
+// ---------------------------------------------------------------------------
+// Foreground handler
+// ---------------------------------------------------------------------------
+
+interface ForegroundOptions {
+  shouldShowBanner?: boolean;
+  shouldShowList?: boolean;
+  shouldPlaySound?: boolean;
+  shouldSetBadge?: boolean;
+}
+
+export function setForegroundHandler(options?: ForegroundOptions) {
+  if (!Device.isDevice) return;
+  try {
+    Notifications.setNotificationHandler({
+      handleNotification: async () => ({
+        shouldShowBanner: options?.shouldShowBanner ?? true,
+        shouldShowList: options?.shouldShowList ?? true,
+        shouldPlaySound: options?.shouldPlaySound ?? true,
+        shouldSetBadge: options?.shouldSetBadge ?? false,
+      }),
+    });
+  } catch (e) {
+    if (__DEV__) console.warn("[Notification] setForegroundHandler failed:", e);
+  }
+}
+
+export function registerBackgroundTask() {
+  if (!Device.isDevice) return;
+  try {
+    Notifications.registerTaskAsync(BACKGROUND_NOTIFICATION_TASK);
+  } catch (e) {
+    if (__DEV__) console.warn("[Notification] registerTaskAsync failed:", e);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Permissions
+// ---------------------------------------------------------------------------
+
+export async function getPermissionStatus() {
+  const settings = await Notifications.getPermissionsAsync();
+  return {
+    granted: settings.granted,
+    status: settings.status,
+    canAskAgain: settings.canAskAgain,
+    ios: settings.ios,
+  };
+}
+
+export async function requestPermission() {
+  const settings = await Notifications.requestPermissionsAsync({
+    ios: {
+      allowAlert: true,
+      allowBadge: true,
+      allowSound: true,
+      allowCriticalAlerts: false,
+      allowProvisional: false,
+      provideAppNotificationSettings: true,
+    },
+  });
+  return {
+    granted: settings.granted,
+    status: settings.status,
+    canAskAgain: settings.canAskAgain,
+    ios: settings.ios,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Push tokens
+// ---------------------------------------------------------------------------
+
+export async function getExpoPushToken(): Promise<string | null> {
+  if (!Device.isDevice) return null;
+
+  const projectId = Constants?.expoConfig?.extra?.eas?.projectId ?? Constants?.easConfig?.projectId;
+  if (!projectId) {
+    console.warn("[Notification] EAS projectId not found");
+    return null;
+  }
+
+  try {
+    const { data } = await Notifications.getExpoPushTokenAsync({ projectId });
+    return data;
+  } catch (e) {
+    console.error("[Notification] Failed to get Expo push token:", e);
+    return null;
+  }
+}
+
+export async function getDevicePushToken(): Promise<string | null> {
+  if (!Device.isDevice) return null;
+
+  try {
+    const { data } = await Notifications.getDevicePushTokenAsync();
+    return data;
+  } catch (e) {
+    console.error("[Notification] Failed to get device push token:", e);
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Scheduling
+// ---------------------------------------------------------------------------
+
+type ContentInput = Notifications.NotificationContentInput;
+type TriggerInput = Notifications.NotificationTriggerInput;
+
+export function scheduleNotification(content: ContentInput, trigger: TriggerInput) {
+  return Notifications.scheduleNotificationAsync({ content, trigger });
+}
+
+export function scheduleTimeInterval(content: ContentInput, seconds: number, repeats = false) {
+  return scheduleNotification(content, {
+    type: Notifications.SchedulableTriggerInputTypes.TIME_INTERVAL,
+    seconds,
+    repeats,
+  });
+}
+
+export function scheduleDate(content: ContentInput, date: Date | number) {
+  return scheduleNotification(content, {
+    type: Notifications.SchedulableTriggerInputTypes.DATE,
+    date,
+  });
+}
+
+export function scheduleCalendar(
+  content: ContentInput,
+  dateComponents: Omit<Notifications.CalendarTriggerInput, "type" | "repeats">,
+  repeats = false,
+) {
+  return scheduleNotification(content, {
+    type: Notifications.SchedulableTriggerInputTypes.CALENDAR,
+    ...dateComponents,
+    repeats,
+  });
+}
+
+export function scheduleDaily(content: ContentInput, hour: number, minute: number) {
+  return scheduleNotification(content, {
+    type: Notifications.SchedulableTriggerInputTypes.DAILY,
+    hour,
+    minute,
+  });
+}
+
+export function scheduleWeekly(
+  content: ContentInput,
+  weekday: number,
+  hour: number,
+  minute: number,
+) {
+  return scheduleNotification(content, {
+    type: Notifications.SchedulableTriggerInputTypes.WEEKLY,
+    weekday,
+    hour,
+    minute,
+  });
+}
+
+export function scheduleMonthly(content: ContentInput, day: number, hour: number, minute: number) {
+  return scheduleNotification(content, {
+    type: Notifications.SchedulableTriggerInputTypes.MONTHLY,
+    day,
+    hour,
+    minute,
+  });
+}
+
+export function scheduleYearly(
+  content: ContentInput,
+  month: number,
+  day: number,
+  hour: number,
+  minute: number,
+) {
+  return scheduleNotification(content, {
+    type: Notifications.SchedulableTriggerInputTypes.YEARLY,
+    month,
+    day,
+    hour,
+    minute,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Schedule management
+// ---------------------------------------------------------------------------
+
+export function getAllScheduled() {
+  return Notifications.getAllScheduledNotificationsAsync();
+}
+
+export function cancelScheduled(id: string) {
+  return Notifications.cancelScheduledNotificationAsync(id);
+}
+
+export function cancelAllScheduled() {
+  return Notifications.cancelAllScheduledNotificationsAsync();
+}
+
+export async function getNextTriggerDate(
+  trigger: Notifications.SchedulableNotificationTriggerInput,
+): Promise<Date | null> {
+  const timestamp = await Notifications.getNextTriggerDateAsync(trigger);
+  return timestamp ? new Date(timestamp) : null;
+}
+
+// ---------------------------------------------------------------------------
+// Badge
+// ---------------------------------------------------------------------------
+
+export function getBadgeCount() {
+  return Notifications.getBadgeCountAsync();
+}
+
+export function setBadgeCount(count: number) {
+  return Notifications.setBadgeCountAsync(count);
+}
+
+// ---------------------------------------------------------------------------
+// Dismiss
+// ---------------------------------------------------------------------------
+
+export function dismissNotification(id: string) {
+  return Notifications.dismissNotificationAsync(id);
+}
+
+export function dismissAllNotifications() {
+  return Notifications.dismissAllNotificationsAsync();
+}
+
+// ---------------------------------------------------------------------------
+// Presented notifications
+// ---------------------------------------------------------------------------
+
+export function getPresentedNotifications() {
+  return Notifications.getPresentedNotificationsAsync();
+}
+
+// ---------------------------------------------------------------------------
+// Last notification response
+// ---------------------------------------------------------------------------
+
+export function clearLastNotificationResponse() {
+  Notifications.clearLastNotificationResponse();
+}