@sneat/auth-core 0.1.1

package/src/lib/sneat-auth.interface.spec.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ILoginEventsHandler,
+  LoginEventsHandler,
+} from './sneat-auth.interface';
+
+describe('sneat-auth.interface', () => {
+  describe('LoginEventsHandler', () => {
+    it('should be an InjectionToken', () => {
+      expect(LoginEventsHandler).toBeDefined();
+      expect(LoginEventsHandler.toString()).toContain('ILoginEventsHandler');
+    });
+  });
+
+  describe('ILoginEventsHandler interface', () => {
+    it('should be implemented by objects with onLoggedIn method', () => {
+      const handler: ILoginEventsHandler = {
+        onLoggedIn: () => {
+          // Implementation
+        },
+      };
+
+      expect(handler).toBeDefined();
+      expect(typeof handler.onLoggedIn).toBe('function');
+    });
+
+    it('should allow onLoggedIn to be called', () => {
+      let called = false;
+      const handler: ILoginEventsHandler = {
+        onLoggedIn: () => {
+          called = true;
+        },
+      };
+
+      handler.onLoggedIn();
+      expect(called).toBe(true);
+    });
+  });
+});

package/src/lib/sneat-auth.interface.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+
+export interface ILoginEventsHandler {
+  onLoggedIn(): void;
+}
+
+export const LoginEventsHandler = new InjectionToken('ILoginEventsHandler');

package/src/lib/telegram-auth.service.spec.ts

@@ -0,0 +1,186 @@
+import { TestBed } from '@angular/core/testing';
+import { SneatApiService } from '@sneat/api';
+import { ErrorLogger } from '@sneat/core';
+import { SneatAuthStateService } from './sneat-auth-state-service';
+import { TelegramAuthService } from './telegram-auth.service';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { of, throwError } from 'rxjs';
+
+describe('TelegramAuthService', () => {
+  let service: TelegramAuthService;
+  let sneatApiServiceMock: { postAsAnonymous: ReturnType<typeof vi.fn> };
+  let authStateServiceMock: { signInWithToken: ReturnType<typeof vi.fn> };
+  let errorLoggerMock: { logErrorHandler: ReturnType<typeof vi.fn> };
+
+  beforeEach(() => {
+    sneatApiServiceMock = {
+      postAsAnonymous: vi.fn(),
+    };
+
+    authStateServiceMock = {
+      signInWithToken: vi.fn().mockResolvedValue({}),
+    };
+
+    errorLoggerMock = {
+      logErrorHandler: vi.fn().mockReturnValue((err: unknown) => {
+        console.error(err);
+      }),
+    };
+
+    TestBed.configureTestingModule({
+      providers: [
+        TelegramAuthService,
+        {
+          provide: ErrorLogger,
+          useValue: errorLoggerMock,
+        },
+        {
+          provide: SneatAuthStateService,
+          useValue: authStateServiceMock,
+        },
+        {
+          provide: SneatApiService,
+          useValue: sneatApiServiceMock,
+        },
+      ],
+    });
+    service = TestBed.inject(TelegramAuthService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should not authenticate if Telegram WebApp is not available', () => {
+    delete (window as unknown as { Telegram?: unknown }).Telegram;
+
+    service.authenticateIfTelegramWebApp();
+
+    expect(sneatApiServiceMock.postAsAnonymous).not.toHaveBeenCalled();
+  });
+
+  it('should not authenticate if Telegram WebApp initData is missing', () => {
+    (
+      window as unknown as { Telegram: { WebApp: { initData?: unknown } } }
+    ).Telegram = {
+      WebApp: {},
+    };
+
+    service.authenticateIfTelegramWebApp();
+
+    expect(sneatApiServiceMock.postAsAnonymous).not.toHaveBeenCalled();
+  });
+
+  it('should authenticate with Telegram WebApp', () => {
+    const mockInitData = 'test-init-data';
+    const mockToken = 'firebase-token-123';
+    const mockReady = vi.fn();
+
+    (
+      window as unknown as {
+        Telegram: { WebApp: { initData: string; ready: () => void } };
+      }
+    ).Telegram = {
+      WebApp: {
+        initData: mockInitData,
+        ready: mockReady,
+      },
+    };
+
+    sneatApiServiceMock.postAsAnonymous.mockReturnValue(
+      of({ token: mockToken }),
+    );
+
+    service.authenticateIfTelegramWebApp();
+
+    expect(sneatApiServiceMock.postAsAnonymous).toHaveBeenCalledWith(
+      'auth/login-from-telegram-miniapp',
+      mockInitData,
+    );
+  });
+
+  it('should call signInWithToken on successful API response', async () => {
+    const mockInitData = 'test-init-data';
+    const mockToken = 'firebase-token-123';
+    const mockReady = vi.fn();
+
+    (
+      window as unknown as {
+        Telegram: { WebApp: { initData: string; ready: () => void } };
+      }
+    ).Telegram = {
+      WebApp: {
+        initData: mockInitData,
+        ready: mockReady,
+      },
+    };
+
+    sneatApiServiceMock.postAsAnonymous.mockReturnValue(
+      of({ token: mockToken }),
+    );
+
+    service.authenticateIfTelegramWebApp();
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(authStateServiceMock.signInWithToken).toHaveBeenCalledWith(
+      mockToken,
+    );
+    expect(mockReady).toHaveBeenCalled();
+  });
+
+  it('should handle API error gracefully', () => {
+    const mockInitData = 'test-init-data';
+
+    (
+      window as unknown as { Telegram: { WebApp: { initData: string } } }
+    ).Telegram = {
+      WebApp: {
+        initData: mockInitData,
+      },
+    };
+
+    sneatApiServiceMock.postAsAnonymous.mockReturnValue(
+      throwError(() => new Error('API Error')),
+    );
+
+    service.authenticateIfTelegramWebApp();
+
+    expect(sneatApiServiceMock.postAsAnonymous).toHaveBeenCalled();
+    expect(errorLoggerMock.logErrorHandler).toHaveBeenCalledWith(
+      'Failed to get Firebase auth token issued using telegram web-app credentials',
+    );
+  });
+
+  it('should handle signInWithToken error gracefully', async () => {
+    const mockInitData = 'test-init-data';
+    const mockToken = 'firebase-token-123';
+
+    (
+      window as unknown as {
+        Telegram: { WebApp: { initData: string; ready: () => void } };
+      }
+    ).Telegram = {
+      WebApp: {
+        initData: mockInitData,
+        ready: vi.fn(),
+      },
+    };
+
+    sneatApiServiceMock.postAsAnonymous.mockReturnValue(
+      of({ token: mockToken }),
+    );
+
+    authStateServiceMock.signInWithToken.mockRejectedValue(
+      new Error('Sign in error'),
+    );
+
+    service.authenticateIfTelegramWebApp();
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(errorLoggerMock.logErrorHandler).toHaveBeenCalledWith(
+      'Failed to sign-in to Firebase auth with a token issued for telegram web-app credentials',
+    );
+  });
+});

package/src/lib/telegram-auth.service.ts

@@ -0,0 +1,49 @@
+import { Injectable, inject } from '@angular/core';
+import { SneatApiService } from '@sneat/api';
+import { SneatAuthStateService } from './sneat-auth-state-service';
+import { ErrorLogger, IErrorLogger } from '@sneat/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class TelegramAuthService {
+  private readonly errorLogger = inject<IErrorLogger>(ErrorLogger);
+  private readonly authStateService = inject(SneatAuthStateService);
+  private readonly sneatApiService = inject(SneatApiService);
+
+  public authenticateIfTelegramWebApp() {
+    const telegramWebApp = (
+      window as unknown as {
+        Telegram?: {
+          WebApp?: {
+            initData: unknown;
+            ready: () => void;
+          };
+        };
+      }
+    ).Telegram?.WebApp;
+    if (telegramWebApp?.initData) {
+      this.sneatApiService
+        .postAsAnonymous<{
+          token: string;
+        }>('auth/login-from-telegram-miniapp', telegramWebApp?.initData)
+        .subscribe({
+          next: (response) => {
+            this.authStateService
+              .signInWithToken(response.token)
+              .then(() => {
+                telegramWebApp.ready();
+              })
+              .catch(
+                this.errorLogger.logErrorHandler(
+                  'Failed to sign-in to Firebase auth with a token issued for telegram web-app credentials',
+                ),
+              );
+          },
+          error: this.errorLogger.logErrorHandler(
+            'Failed to get Firebase auth token issued using telegram web-app credentials',
+          ),
+        });
+    }
+  }
+}

package/src/lib/user/index.ts

@@ -0,0 +1,2 @@
+export * from './user-record.service';
+export * from './sneat-user.service';

package/src/lib/user/sneat-user.service.spec.ts

@@ -0,0 +1,151 @@
+import { TestBed } from '@angular/core/testing';
+import {
+  Firestore as AngularFirestore,
+  CollectionReference,
+} from '@angular/fire/firestore';
+import { SneatApiService } from '@sneat/api';
+import { ErrorLogger } from '@sneat/core';
+import {
+  SneatAuthStateService,
+  ISneatAuthState,
+} from '../sneat-auth-state-service';
+import { UserRecordService } from './user-record.service';
+import { SneatUserService } from './sneat-user.service';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { of, Subject, firstValueFrom } from 'rxjs';
+
+// Mock firestore functions
+vi.mock('@angular/fire/firestore', async () => {
+  const actual = await vi.importActual('@angular/fire/firestore');
+  return {
+    ...actual,
+    collection: vi
+      .fn()
+      .mockReturnValue({ id: 'users' } as unknown as CollectionReference),
+    doc: vi.fn(),
+    onSnapshot: vi.fn(),
+  };
+});
+
+describe('SneatUserService', () => {
+  let service: SneatUserService;
+  let authStateSubject: Subject<ISneatAuthState>;
+  let sneatApiServiceMock: { post: ReturnType<typeof vi.fn> };
+  let userRecordServiceMock: { initUserRecord: ReturnType<typeof vi.fn> };
+  let firestoreMock: Record<string, unknown>;
+
+  beforeEach(() => {
+    authStateSubject = new Subject<ISneatAuthState>();
+
+    sneatApiServiceMock = {
+      post: vi.fn().mockReturnValue(of(void 0)),
+    };
+
+    userRecordServiceMock = {
+      initUserRecord: vi
+        .fn()
+        .mockReturnValue(of({ id: 'user123', title: 'Test User' })),
+    };
+
+    firestoreMock = {
+      app: {},
+      type: 'firestore',
+    };
+
+    TestBed.configureTestingModule({
+      providers: [
+        SneatUserService,
+        {
+          provide: AngularFirestore,
+          useValue: firestoreMock,
+        },
+        {
+          provide: ErrorLogger,
+          useValue: {
+            logError: vi.fn(),
+            logErrorHandler: vi.fn().mockReturnValue(() => undefined),
+          },
+        },
+        {
+          provide: SneatAuthStateService,
+          useValue: {
+            authState: authStateSubject.asObservable(),
+          },
+        },
+        {
+          provide: SneatApiService,
+          useValue: sneatApiServiceMock,
+        },
+        {
+          provide: UserRecordService,
+          useValue: userRecordServiceMock,
+        },
+      ],
+    });
+
+    service = TestBed.inject(SneatUserService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should have currentUserID as undefined initially', () => {
+    expect(service.currentUserID).toBeUndefined();
+  });
+
+  it('should call setUserCountry with correct parameters', async () => {
+    const countryID = 'US';
+    await firstValueFrom(service.setUserCountry(countryID));
+    expect(sneatApiServiceMock.post).toHaveBeenCalledWith(
+      'users/set_user_country',
+      { countryID },
+    );
+  });
+
+  it('should update currentUserID when user signs in', () => {
+    const authState: ISneatAuthState = {
+      status: 'authenticated',
+      user: {
+        uid: 'test-uid-123',
+        email: 'test@example.com',
+        emailVerified: true,
+        displayName: 'Test User',
+        providerId: 'google.com',
+        isAnonymous: false,
+        providerData: [],
+        photoURL: null,
+        phoneNumber: null,
+      },
+    };
+
+    service.onUserSignedIn(authState);
+
+    expect(service.currentUserID).toBe('test-uid-123');
+  });
+
+  it('should not change currentUserID if uid is the same', () => {
+    const authState: ISneatAuthState = {
+      status: 'authenticated',
+      user: {
+        uid: 'test-uid-123',
+        email: 'test@example.com',
+        emailVerified: true,
+        displayName: 'Test User',
+        providerId: 'google.com',
+        isAnonymous: false,
+        providerData: [],
+        photoURL: null,
+        phoneNumber: null,
+      },
+    };
+
+    service.onUserSignedIn(authState);
+    const firstUserID = service.currentUserID;
+
+    service.onUserSignedIn(authState); // Second call with same uid
+
+    expect(service.currentUserID).toBe(firstUserID);
+    expect(service.currentUserID).toBe('test-uid-123');
+  });
+});

package/src/lib/user/sneat-user.service.ts

@@ -0,0 +1,266 @@
+import {
+  Injectable,
+  inject,
+  Injector,
+  runInInjectionContext,
+} from '@angular/core';
+import {
+  // Action,
+  Firestore as AngularFirestore,
+  CollectionReference,
+  DocumentSnapshot,
+  collection,
+  doc,
+  onSnapshot,
+  Unsubscribe,
+} from '@angular/fire/firestore';
+import { SneatApiService } from '@sneat/api';
+import { IUserRecord } from '@sneat/auth-models';
+import { ErrorLogger, IErrorLogger } from '@sneat/core';
+import {
+  initialSneatAuthState,
+  ISneatAuthState,
+  ISneatAuthUser,
+  SneatAuthStateService,
+} from '../sneat-auth-state-service';
+import { BehaviorSubject, Observable, ReplaySubject } from 'rxjs';
+import {
+  IInitUserRecordRequest,
+  UserRecordService,
+} from './user-record.service';
+
+export interface ISneatUserState extends ISneatAuthState {
+  record?: IUserRecord | null; // undefined => not loaded yet, null = does not exists
+}
+
+const UsersCollection = 'users';
+
+@Injectable({ providedIn: 'root' }) // TODO: lazy loading
+export class SneatUserService {
+  private readonly errorLogger = inject<IErrorLogger>(ErrorLogger);
+  private readonly sneatApiService = inject(SneatApiService);
+  private readonly userRecordService = inject(UserRecordService);
+
+  // private userDocSubscription?: Subscription;
+  private readonly injector = inject(Injector);
+  private readonly userCollection: CollectionReference<IUserRecord>;
+  private readonly userDocRef = (uid: string) =>
+    runInInjectionContext(this.injector, () => doc(this.userCollection, uid));
+
+  private uid?: string;
+  private $userTitle?: string;
+
+  private readonly userChanged$ = new ReplaySubject<string | undefined>(1);
+  public readonly userChanged = this.userChanged$.asObservable();
+
+  private readonly userState$ = new BehaviorSubject<ISneatUserState>(
+    initialSneatAuthState,
+  );
+
+  public readonly userState = this.userState$.asObservable();
+
+  private _unsubscribeFromUserDoc?: Unsubscribe;
+
+  private unsubscribeFromUserDoc(_from: string) {
+    if (this._unsubscribeFromUserDoc) {
+      // console.log(
+      //   'SneatUserService.unsubscribeFromUserDoc() called from ' + _from,
+      // );
+      this._unsubscribeFromUserDoc();
+      this._unsubscribeFromUserDoc = undefined;
+    }
+  }
+
+  constructor() {
+    const afs = inject(AngularFirestore);
+    const sneatAuthStateService = inject(SneatAuthStateService);
+    this.userCollection = collection(
+      afs,
+      UsersCollection,
+    ) as CollectionReference<IUserRecord>;
+    sneatAuthStateService.authState.subscribe({
+      next: this.onAuthStateChanged,
+      error: this.errorLogger.logErrorHandler('failed to get sneat auth state'),
+    });
+  }
+
+  public get currentUserID(): string | undefined {
+    return this.uid;
+  }
+
+  // public get userTitle(): string | undefined {
+  // 	return this.$userTitle;
+  // }
+
+  public setUserCountry(countryID: string): Observable<void> {
+    return this.sneatApiService.post('users/set_user_country', { countryID });
+  }
+
+  public onUserSignedIn(authState: ISneatAuthState): void {
+    const authUser = authState.user;
+    // afUser.getIdToken().then(idToken => {
+    // 	console.log('Firebase idToken:', idToken);
+    // }).catch(err => this.errorLoggerService.logError(err, 'Failed to get Firebase ID token'));
+    if (authUser?.email && authUser.emailVerified) {
+      this.$userTitle = authUser.email;
+    }
+    if (this.uid === authUser?.uid) {
+      return;
+    }
+    this.unsubscribeFromUserDoc('onUserSignedIn()');
+    if (!authUser) {
+      if (this.userState$.value?.record !== null) {
+        this.userState$.next({ ...this.userState$.value });
+      }
+      return;
+    }
+    const { uid } = authUser;
+    this.uid = uid;
+    this.userState$.next({
+      ...authState,
+    });
+    this.userChanged$.next(uid);
+    this.watchUserRecord(uid, authState);
+  }
+
+  private watchUserRecord(uid: string, authState: ISneatAuthState): void {
+    // console.log(
+    //   `SneatUserService.watchUserRecord(uid=${uid}): Loading user record...`,
+    // );
+    this.unsubscribeFromUserDoc('whatUserRecord()');
+
+    // TODO: Remove - setTimeout() not needed but trying to troubleshoot user record issue
+    setTimeout(() => {
+      try {
+        const userDocRef = this.userDocRef(uid);
+        this._unsubscribeFromUserDoc = runInInjectionContext(
+          this.injector,
+          () =>
+            onSnapshot(userDocRef, {
+              next: (userDocSnapshot) => {
+                // console.log(
+                //   `SneatUserService.watchUserRecord(uid=${uid}) => userDocSnapshot:`,
+                //   userDocSnapshot,
+                // );
+                this.onAuthStateChanged(authState);
+                this.userDocChanged(userDocSnapshot, authState);
+              },
+              error: (err) => {
+                console.error(
+                  `SneatUserService.watchUserRecord(uid=${uid}) => failed:`,
+                  err,
+                );
+              },
+            }),
+        );
+      } catch (err) {
+        console.error(
+          `SneatUserService.watchUserRecord(uid=${uid}) => Failed to setup watcher for user record::`,
+          err,
+        );
+        return;
+      }
+    }, 100);
+  }
+
+  private onAuthStateChanged = (authState: ISneatAuthState): void => {
+    // console.log('SneatUserService => authState changed:', authState);
+    if (authState.user) {
+      this.onUserSignedIn(authState);
+    } else {
+      this.userState$.next(authState);
+      this.userChanged$.next(undefined);
+      this.onUserSignedOut();
+    }
+  };
+
+  private userDocChanged(
+    userDocSnapshot: DocumentSnapshot<IUserRecord>,
+    authState: ISneatAuthState,
+  ): void {
+    // console.log(
+    //   'SneatUserService.userDocChanged() => userDocSnapshot.exists:',
+    //   userDocSnapshot.exists(),
+    //   'authState:',
+    //   authState,
+    //   'userDocSnapshot:',
+    //   userDocSnapshot,
+    // );
+    if (userDocSnapshot.ref.id !== this.uid) {
+      console.error(
+        'userDocSnapshot.ref.id !== this.uid - Should always be equal as we unsubscribe if uid changes',
+      );
+      return;
+    }
+    // console.log('SneatUserService => userDocSnapshot.exists:', userDocSnapshot.exists)
+    const authUser = authState.user;
+    if (authUser && !userDocSnapshot.exists()) {
+      this.initUserRecordFromAuthUser(authUser);
+    }
+    const userRecord: IUserRecord | null = userDocSnapshot.exists()
+      ? (userDocSnapshot.data() as IUserRecord)
+      : authUser
+        ? { title: authUser.displayName || authUser.email || authUser.uid }
+        : null;
+
+    this.userState$.next({
+      ...authState,
+      record: userRecord,
+    });
+  }
+
+  private initUserRecordFromAuthUser(authUser: ISneatAuthUser): void {
+    let request: IInitUserRecordRequest = {
+      email: authUser.email || undefined,
+      emailIsVerified: authUser.emailVerified,
+      authProvider: authUser?.providerId,
+    };
+    if (authUser?.displayName) {
+      request = { ...request, names: { fullName: authUser.displayName } };
+    }
+    this.userRecordService.initUserRecord(request).subscribe({
+      next: (_userDto) => {
+        // User record created successfully - no additional action needed
+      },
+      error: this.errorLogger.logErrorHandler('failed to create user record'),
+    });
+  }
+
+  private onUserSignedOut(): void {
+    this.uid = undefined;
+    this.unsubscribeFromUserDoc('onUserSignedOut()');
+  }
+
+  // private createUserRecord(userDocRef: DocumentReference, authUser: ISneatAuthUser): void {
+  // 	if (this.userState$.value) {
+  // 		return;
+  // 	}
+  // 	this.db.firestore.runTransaction(async tx => {
+  // 		if (this.userState$.value) {
+  // 			return undefined;
+  // 		}
+  // 		const u = await tx.get(userDocRef);
+  // 		if (!u.exists) {
+  // 			const title = authUser.displayName || authUser.email || authUser.uid;
+  // 			const user: IUserRecord = authUser.email
+  // 				? {title, email: authUser.email, emailVerified: authUser.emailVerified}
+  // 				: {title};
+  // 			await tx.set(userDocRef, user);
+  // 			return user;
+  // 		}
+  // 		return undefined;
+  // 	}).then(user => {
+  // 		if (user) {
+  // 			console.log('user record created:', user);
+  // 		}
+  // 		if (!this.userState$.value) {
+  // 			const userState: ISneatUserState = {
+  // 				status: AuthStatuses.authenticated,
+  // 				record: user,
+  // 				user: authUser,
+  // 			};
+  // 			this.userState$.next(userState);
+  // 		}
+  // 	}).catch(this.errorLogger.logErrorHandler('failed to create user record'));
+  // }
+}