Push Notifications without Clerk

.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run typecheck, lint, and format checks
+        run: bun run check
+
+      - name: Run tests
+        run: bun run test:run

package.json

@@ -4,8 +4,9 @@
 	"type": "module",
 	"scripts": {
 		"dev": "astro dev",
-		"build": "bun test:run && astro check && astro build",
-		"build:node": "ASTRO_ADAPTER=node astro check && ASTRO_ADAPTER=node astro build",
+		"build": "astro build",
+		"build:prod": "astro build",
+		"build:node": "ASTRO_ADAPTER=node astro build",
 		"preview": "astro preview --port 4322",
 		"preview:node": "ASTRO_ADAPTER=node dotenv -e .env -- astro preview --port 4322",
 		"check": "concurrently -n Astro,Prettier,ESLint \"astro check\" \"prettier --check .\" \"eslint . --ext .ts,.tsx,.js,.jsx,.astro\"",

src/app/features/notification-settings.tsx

@@ -1,7 +1,7 @@
 import { de as dfnsDe } from "date-fns/locale"
 import { formatDistanceToNow } from "date-fns"
 import { useIsAuthenticated } from "jazz-tools/react"
-import { co } from "jazz-tools"
+import { co, generateAuthToken } from "jazz-tools"
 import { PushDevice, UserAccount } from "#shared/schema/user"
 import { Alert, AlertTitle, AlertDescription } from "#shared/ui/alert"
 import { ExclamationTriangle } from "react-bootstrap-icons"
@@ -55,6 +55,7 @@ import { PUBLIC_VAPID_KEY } from "astro:env/client"
 import { getServiceWorkerRegistration } from "#app/lib/service-worker"
 import { tryCatch } from "#shared/lib/trycatch"
 import { isInAppBrowser } from "#app/hooks/use-pwa"
+import { triggerNotificationRegistration } from "#app/lib/notification-registration"
 
 export function NotificationSettings({
 	me,
@@ -967,11 +968,29 @@ function AddDeviceDialog({ me, disabled }: AddDeviceDialogProps) {
 			return
 		}
 
-		addPushDevice({
+		let deviceData = {
 			deviceName: values.deviceName,
 			endpoint: subscriptionResult.data.endpoint,
 			keys: subscriptionResult.data.keys,
-		})
+		}
+
+		if (notifications?.$jazz.id) {
+			let authToken = generateAuthToken(me)
+			let registrationResult = await triggerNotificationRegistration(
+				notifications.$jazz.id,
+				authToken,
+			)
+			if (!registrationResult.ok) {
+				toast.warning(t("notifications.toast.registrationFailed"))
+				setOpen(false)
+				form.reset({
+					deviceName: getDeviceName(),
+				})
+				return
+			}
+		}
+
+		addPushDevice(deviceData)
 
 		toast.success(t("notifications.toast.deviceAdded"))
 		setOpen(false)

src/app/hooks/use-register-notifications.test.ts

@@ -0,0 +1,62 @@
+import { describe, test, expect } from "vitest"
+import { findLatestFutureDate } from "#app/lib/reminder-utils"
+
+describe("findLatestFutureDate", () => {
+	let today = "2025-01-15"
+
+	test("returns undefined for empty list", () => {
+		expect(findLatestFutureDate([], today)).toBeUndefined()
+	})
+
+	test("returns undefined when all reminders are in the past", () => {
+		let reminders = [
+			{ dueAtDate: "2025-01-10", deleted: false, done: false },
+			{ dueAtDate: "2025-01-14", deleted: false, done: false },
+		]
+		expect(findLatestFutureDate(reminders, today)).toBeUndefined()
+	})
+
+	test("returns the only future reminder", () => {
+		let reminders = [{ dueAtDate: "2025-01-20", deleted: false, done: false }]
+		expect(findLatestFutureDate(reminders, today)).toBe("2025-01-20")
+	})
+
+	test("returns today's date as valid future", () => {
+		let reminders = [{ dueAtDate: "2025-01-15", deleted: false, done: false }]
+		expect(findLatestFutureDate(reminders, today)).toBe("2025-01-15")
+	})
+
+	test("returns the latest of multiple future reminders", () => {
+		let reminders = [
+			{ dueAtDate: "2025-01-20", deleted: false, done: false },
+			{ dueAtDate: "2025-02-15", deleted: false, done: false },
+			{ dueAtDate: "2025-01-25", deleted: false, done: false },
+		]
+		expect(findLatestFutureDate(reminders, today)).toBe("2025-02-15")
+	})
+
+	test("ignores deleted reminders", () => {
+		let reminders = [
+			{ dueAtDate: "2025-02-15", deleted: true, done: false },
+			{ dueAtDate: "2025-01-20", deleted: false, done: false },
+		]
+		expect(findLatestFutureDate(reminders, today)).toBe("2025-01-20")
+	})
+
+	test("ignores done reminders", () => {
+		let reminders = [
+			{ dueAtDate: "2025-02-15", deleted: false, done: true },
+			{ dueAtDate: "2025-01-20", deleted: false, done: false },
+		]
+		expect(findLatestFutureDate(reminders, today)).toBe("2025-01-20")
+	})
+
+	test("returns undefined when all future reminders are deleted or done", () => {
+		let reminders = [
+			{ dueAtDate: "2025-02-15", deleted: true, done: false },
+			{ dueAtDate: "2025-01-20", deleted: false, done: true },
+			{ dueAtDate: "2025-01-10", deleted: false, done: false },
+		]
+		expect(findLatestFutureDate(reminders, today)).toBeUndefined()
+	})
+})

src/app/hooks/use-register-notifications.ts

@@ -0,0 +1,161 @@
+import { useEffect, useRef } from "react"
+import { useAccount } from "jazz-tools/react"
+import {
+	Group,
+	generateAuthToken,
+	type co,
+	type ResolveQuery,
+} from "jazz-tools"
+import { PUBLIC_JAZZ_WORKER_ACCOUNT } from "astro:env/client"
+import { UserAccount } from "#shared/schema/user"
+import { tryCatch } from "#shared/lib/trycatch"
+import {
+	migrateNotificationSettings,
+	addServerToGroup,
+} from "#app/lib/notification-settings-migration"
+import { triggerNotificationRegistration } from "#app/lib/notification-registration"
+import { findLatestFutureDate } from "#app/lib/reminder-utils"
+
+export { useRegisterNotifications }
+
+let notificationSettingsQuery = {
+	root: {
+		notificationSettings: true,
+		people: { $each: { reminders: { $each: true } } },
+	},
+} as const satisfies ResolveQuery<typeof UserAccount>
+
+type LoadedAccount = co.loaded<
+	typeof UserAccount,
+	typeof notificationSettingsQuery
+>
+
+/**
+ * Hook that registers notification settings with the server.
+ * Handles migration from account-owned to group-owned settings.
+ * Runs once on app start.
+ */
+function useRegisterNotifications(): void {
+	let registrationRan = useRef(false)
+	let me = useAccount(UserAccount, { resolve: notificationSettingsQuery })
+
+	useEffect(() => {
+		if (registrationRan.current || !me.$isLoaded) return
+		if (!me.root.notificationSettings) return
+
+		registrationRan.current = true
+		registerNotificationSettings(me).catch(error => {
+			console.error("[Notifications] Registration error:", error)
+			registrationRan.current = false
+		})
+	}, [me.$isLoaded, me])
+}
+
+async function registerNotificationSettings(me: LoadedAccount): Promise<void> {
+	let notificationSettings = me.root.notificationSettings
+	if (!notificationSettings) return
+
+	let serverAccountId = PUBLIC_JAZZ_WORKER_ACCOUNT
+	if (!serverAccountId) {
+		console.error("[Notifications] PUBLIC_JAZZ_WORKER_ACCOUNT not configured")
+		return
+	}
+
+	// Sync language from root to notification settings
+	let rootLanguage = me.root.language
+	if (rootLanguage && notificationSettings.language !== rootLanguage) {
+		notificationSettings.$jazz.set("language", rootLanguage)
+	}
+
+	// Compute and sync latestReminderDueDate
+	let latestDueDate = computeLatestReminderDueDate(me)
+	if (latestDueDate !== notificationSettings.latestReminderDueDate) {
+		notificationSettings.$jazz.set("latestReminderDueDate", latestDueDate)
+	}
+
+	// Check if settings are owned by a shareable group
+	// The key difference: if owner is an Account vs a Group
+	let owner = notificationSettings.$jazz.owner
+	let isShareableGroup = owner instanceof Group
+
+	if (!isShareableGroup) {
+		console.log("[Notifications] Migrating to shareable group")
+		let migrationResult = await tryCatch(
+			migrateNotificationSettings(notificationSettings, serverAccountId, {
+				loadAs: me,
+				rootLanguage,
+			}),
+		)
+		if (!migrationResult.ok) {
+			console.error("[Notifications] Migration failed:", migrationResult.error)
+			return
+		}
+		let { newSettings, cleanup } = migrationResult.data
+		// Update root to point to new settings before cleanup
+		me.root.$jazz.set("notificationSettings", newSettings)
+		// Defer cleanup to next tick so new settings are persisted first
+		setTimeout(cleanup, 0)
+		notificationSettings = newSettings
+		console.log("[Notifications] Migration complete")
+	} else {
+		// Ensure server worker is a member
+		let group = owner as Group
+		let serverIsMember = group.members.some(
+			m => m.account?.$jazz.id === serverAccountId,
+		)
+		if (!serverIsMember) {
+			let addResult = await tryCatch(
+				addServerToGroup(group, serverAccountId, { loadAs: me }),
+			)
+			if (!addResult.ok) {
+				console.error(
+					"[Notifications] Failed to add server to group:",
+					addResult.error,
+				)
+			}
+		}
+	}
+
+	// Register with server using Jazz auth
+	let authToken = generateAuthToken(me)
+	let registerResult = await triggerNotificationRegistration(
+		notificationSettings.$jazz.id,
+		authToken,
+	)
+
+	if (!registerResult.ok) {
+		console.error("[Notifications] Registration failed:", registerResult.error)
+		return
+	}
+
+	console.log("[Notifications] Registration successful")
+}
+
+function computeLatestReminderDueDate(me: LoadedAccount): string | undefined {
+	let reminders = extractReminders(me)
+	let timezone =
+		me.root.notificationSettings?.timezone ||
+		Intl.DateTimeFormat().resolvedOptions().timeZone
+	let today = new Date()
+		.toLocaleDateString("sv-SE", { timeZone: timezone })
+		.slice(0, 10)
+	return findLatestFutureDate(reminders, today)
+}
+
+function extractReminders(
+	me: LoadedAccount,
+): { dueAtDate: string; deleted: boolean; done: boolean }[] {
+	let reminders: { dueAtDate: string; deleted: boolean; done: boolean }[] = []
+	for (let person of me.root.people.values()) {
+		if (!person || person.deletedAt) continue
+		for (let reminder of person.reminders.values()) {
+			if (!reminder) continue
+			reminders.push({
+				dueAtDate: reminder.dueAtDate,
+				deleted: !!reminder.deletedAt,
+				done: !!reminder.done,
+			})
+		}
+	}
+	return reminders
+}

src/app/lib/notification-registration.ts

@@ -0,0 +1,43 @@
+import { apiClient } from "#app/lib/api-client"
+import { tryCatch } from "#shared/lib/trycatch"
+
+export { triggerNotificationRegistration }
+
+type RegistrationResult = { ok: true } | { ok: false; error: string }
+
+async function triggerNotificationRegistration(
+	notificationSettingsId: string,
+	authToken: string,
+): Promise<RegistrationResult> {
+	let result = await tryCatch(
+		apiClient.push.register.$post(
+			{
+				json: { notificationSettingsId },
+			},
+			{
+				headers: {
+					Authorization: `Jazz ${authToken}`,
+				},
+			},
+		),
+	)
+
+	if (!result.ok) {
+		console.error("[Notifications] Registration failed:", result.error)
+		return { ok: false, error: "Network error" }
+	}
+
+	if (!result.data.ok) {
+		let errorData = await tryCatch(
+			result.data.json() as Promise<{ message?: string }>,
+		)
+		let errorMessage = errorData.ok
+			? errorData.data.message || "Unknown error"
+			: "Unknown error"
+		console.error("[Notifications] Registration error:", errorMessage)
+		return { ok: false, error: errorMessage }
+	}
+
+	console.log("[Notifications] Registration triggered successfully")
+	return { ok: true }
+}