create-pyric 0.1.0-alpha.14 → 0.1.0-alpha.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pyric",
-  "version": "0.1.0-alpha.14",
+  "version": "0.1.0-alpha.16",
   "license": "Apache-2.0",
   "homepage": "https://pyric.dev",
   "repository": {

package/templates/chat/src/services/presence-service.ts

@@ -1,4 +1,4 @@
-import { onValue, ref, serverTimestamp, set } from 'firebase/database';
+import { onDisconnect, onValue, ref, serverTimestamp, set } from 'firebase/database';
 import { auth, rtdb } from '../firebase/app';
 import { asUserId, type AuthUser, type PresenceEntry, type PresenceRecord, ServiceError } from '../firebase/types';
 import { requireUid } from './firestore-helpers';
@@ -24,19 +24,15 @@ export class PresenceService {
    * `/presence/{uid}` the first time a user comes online, which is what
    * fires the `onPresenceOnline` Cloud Function.
    *
-   * In a production build we also register a real `onDisconnect` so the node
-   * flips to offline when the socket drops. `onDisconnect` is not part of the
-   * sandbox's Realtime Database surface yet (RTDB support is incomplete), so
-   * under `vite dev` we rely on the explicit `goOffline` writes below.
+   * Register `onDisconnect` before publishing the online state so production
+   * and the local sandbox both flip the node to offline on a clean lifecycle
+   * boundary. The explicit `goOffline` method remains the user-driven path.
    */
   async goOnline(user: AuthUser): Promise<void> {
     const uid = requireUid(user.uid);
     try {
       const reference = presenceRef(uid);
-      if (import.meta.env.PROD) {
-        const { onDisconnect } = await import('firebase/database');
-        await onDisconnect(reference).set({ state: 'offline', displayName: user.displayName, at: serverTimestamp() });
-      }
+      await onDisconnect(reference).set({ state: 'offline', displayName: user.displayName, at: serverTimestamp() });
       await set(reference, { state: 'online', displayName: user.displayName, at: serverTimestamp() });
     } catch (error) {
       throw mapRtdbError(error);

package/templates/chat/src/services/provisioning.ts

@@ -0,0 +1,23 @@
+/**
+ * Deduplicates post-sign-in provisioning per user while keeping failures
+ * observable. Concurrent callers share one in-flight attempt, so a failure
+ * reaches every caller instead of being masked by an "already started"
+ * short-circuit. A failed attempt is forgotten, letting the next sign-in
+ * retry from scratch; a successful attempt stays cached so provisioning
+ * runs once per user.
+ */
+export const createProvisioner = <TUser extends { uid: string }>(
+  provision: (user: TUser) => Promise<void>,
+): ((user: TUser) => Promise<void>) => {
+  const attempts = new Map<string, Promise<void>>();
+  return (user) => {
+    const inFlight = attempts.get(user.uid);
+    if (inFlight) return inFlight;
+    const attempt = provision(user).catch((error: unknown) => {
+      attempts.delete(user.uid);
+      throw error;
+    });
+    attempts.set(user.uid, attempt);
+    return attempt;
+  };
+};

package/templates/chat/src/ui/chat/firebase-chat-gateway.ts

@@ -1,4 +1,5 @@
 import { FirebaseAuthService } from '@/services/auth-service';
+import { createProvisioner } from '@/services/provisioning';
 import { ConversationService } from '@/services/conversation-service';
 import { MessageService } from '@/services/message-service';
 import { UserService } from '@/services/user-service';
@@ -42,29 +43,27 @@ export const createFirebaseChatGateway = (): ChatPageServices => {
   const users = new UserService();
   const presence = new PresenceService();
   const notifications = new NotificationService();
-  const provisioned = new Set<string>();
-
-  const provision = async (user: AuthUser): Promise<void> => {
-    if (provisioned.has(user.uid)) return;
-    provisioned.add(user.uid);
-    try {
-      await users.provision(user);
-      await presence.goOnline(user);
-    } catch (error) {
-      provisioned.delete(user.uid);
-      throw error;
-    }
-  };
+  const provision = createProvisioner(async (user: AuthUser) => {
+    await users.provision(user);
+    await presence.goOnline(user);
+  });
 
   return {
     auth: {
       currentUser: () => toUiUser(auth.currentUser()),
+      // Auth state reports the signed-in user as soon as Firebase does; a
+      // provisioning failure must not masquerade as "signed out". The signIn
+      // path awaits the same shared attempt, so its failure surfaces in the
+      // sign-in error UI rather than only here.
       observe: (callback) => auth.observe((user) => {
         if (!user) {
           callback(null);
           return;
         }
-        void provision(user).then(() => callback(toUiUser(user))).catch(() => callback(null));
+        callback(toUiUser(user));
+        provision(user).catch((error: unknown) => {
+          console.error('Post-sign-in provisioning failed; the user profile or presence may be missing.', error);
+        });
       }),
       signIn: async () => {
         const signedIn = await auth.signIn();

package/templates/chat/test/provisioning.test.ts

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createProvisioner } from '../src/services/provisioning.ts';
+
+const user = { uid: 'user-1' };
+
+test('concurrent callers share one attempt and both observe its failure', async () => {
+  let runs = 0;
+  let reject: (reason: Error) => void = () => undefined;
+  const provision = createProvisioner(() => {
+    runs += 1;
+    return new Promise<void>((_resolve, nextReject) => {
+      reject = nextReject;
+    });
+  });
+
+  const observerAttempt = provision(user);
+  const signInAttempt = provision(user);
+  assert.equal(runs, 1);
+
+  reject(new Error('presence write denied'));
+  await assert.rejects(observerAttempt, /presence write denied/);
+  await assert.rejects(signInAttempt, /presence write denied/);
+});
+
+test('a failed attempt is forgotten so the next sign-in retries', async () => {
+  let runs = 0;
+  const provision = createProvisioner(() => {
+    runs += 1;
+    return runs === 1 ? Promise.reject(new Error('offline')) : Promise.resolve();
+  });
+
+  await assert.rejects(provision(user), /offline/);
+  await provision(user);
+  assert.equal(runs, 2);
+});
+
+test('a successful attempt is cached per user', async () => {
+  let runs = 0;
+  const provision = createProvisioner(() => {
+    runs += 1;
+    return Promise.resolve();
+  });
+
+  await provision(user);
+  await provision(user);
+  await provision({ uid: 'user-2' });
+  assert.equal(runs, 2);
+});