@sneat/auth-core 0.1.3 → 0.1.4

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

@@ -1,151 +0,0 @@
-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

@@ -1,266 +0,0 @@
-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'));
-  // }
-}

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

@@ -1,145 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { SneatApiService } from '@sneat/api';
-import { UserRecordService } from './user-record.service';
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { of, firstValueFrom } from 'rxjs';
-import { IUserDbo } from '@sneat/dto';
-
-describe('UserRecordService', () => {
-  let service: UserRecordService;
-  let sneatApiServiceMock: { post: ReturnType<typeof vi.fn> };
-
-  beforeEach(() => {
-    sneatApiServiceMock = {
-      post: vi.fn(),
-    };
-
-    TestBed.configureTestingModule({
-      providers: [
-        UserRecordService,
-        {
-          provide: SneatApiService,
-          useValue: sneatApiServiceMock,
-        },
-      ],
-    });
-    service = TestBed.inject(UserRecordService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  it('should initialize user record with provided request', async () => {
-    const request = {
-      authProvider: 'google.com',
-      email: 'test@example.com',
-      emailIsVerified: true,
-      names: { fullName: 'Test User' },
-    };
-
-    const mockResponse: IUserDbo = {
-      id: 'user123',
-      title: 'Test User',
-    };
-
-    sneatApiServiceMock.post.mockReturnValue(of(mockResponse));
-
-    const result = await firstValueFrom(service.initUserRecord(request));
-
-    expect(result).toEqual(mockResponse);
-    expect(sneatApiServiceMock.post).toHaveBeenCalledWith(
-      'users/init_user_record',
-      expect.objectContaining({
-        authProvider: 'google.com',
-        email: 'test@example.com',
-        emailIsVerified: true,
-        names: { fullName: 'Test User' },
-        ianaTimezone: expect.any(String),
-      }),
-    );
-  });
-
-  it('should add ianaTimezone if not provided', async () => {
-    const request = {
-      email: 'test@example.com',
-    };
-
-    const mockResponse: IUserDbo = {
-      id: 'user123',
-      title: 'Test User',
-    };
-
-    sneatApiServiceMock.post.mockReturnValue(of(mockResponse));
-
-    await firstValueFrom(service.initUserRecord(request));
-
-    const callArgs = sneatApiServiceMock.post.mock.calls[0][1];
-    expect(callArgs.ianaTimezone).toBeDefined();
-    expect(typeof callArgs.ianaTimezone).toBe('string');
-  });
-
-  it('should preserve provided ianaTimezone', async () => {
-    const request = {
-      email: 'test@example.com',
-      ianaTimezone: 'America/New_York',
-    };
-
-    const mockResponse: IUserDbo = {
-      id: 'user123',
-      title: 'Test User',
-    };
-
-    sneatApiServiceMock.post.mockReturnValue(of(mockResponse));
-
-    await firstValueFrom(service.initUserRecord(request));
-
-    expect(sneatApiServiceMock.post).toHaveBeenCalledWith(
-      'users/init_user_record',
-      expect.objectContaining({
-        ianaTimezone: 'America/New_York',
-      }),
-    );
-  });
-
-  it('should exclude undefined values from request', async () => {
-    const request = {
-      email: 'test@example.com',
-      gender: undefined,
-      ageGroup: undefined,
-    };
-
-    const mockResponse: IUserDbo = {
-      id: 'user123',
-      title: 'Test User',
-    };
-
-    sneatApiServiceMock.post.mockReturnValue(of(mockResponse));
-
-    await firstValueFrom(service.initUserRecord(request));
-
-    const callArgs = sneatApiServiceMock.post.mock.calls[0][1];
-    expect(callArgs.gender).toBeUndefined();
-    expect(callArgs.ageGroup).toBeUndefined();
-    expect(callArgs.email).toBe('test@example.com');
-  });
-
-  it('should share the observable for multiple subscribers', async () => {
-    const request = {
-      email: 'test@example.com',
-    };
-
-    const mockResponse: IUserDbo = {
-      id: 'user123',
-      title: 'Test User',
-    };
-
-    sneatApiServiceMock.post.mockReturnValue(of(mockResponse));
-
-    const obs = service.initUserRecord(request);
-
-    await Promise.all([firstValueFrom(obs), firstValueFrom(obs)]);
-
-    expect(sneatApiServiceMock.post).toHaveBeenCalledTimes(1);
-  });
-});

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

@@ -1,38 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import { SneatApiService } from '@sneat/api';
-import { IPersonNames } from '@sneat/auth-models';
-import { AgeGroupID, excludeUndefined, Gender, SpaceType } from '@sneat/core';
-import { IUserDbo } from '@sneat/dto';
-import { Observable, share } from 'rxjs';
-
-@Injectable({ providedIn: 'root' })
-export class UserRecordService {
-  private readonly sneatApiService = inject(SneatApiService);
-
-  private initUserRecord$?: Observable<IUserDbo>;
-
-  public initUserRecord(request: IInitUserRecordRequest): Observable<IUserDbo> {
-    if (!request.ianaTimezone) {
-      request = {
-        ...request,
-        ianaTimezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-      };
-    }
-    request = excludeUndefined(request);
-    this.initUserRecord$ = this.sneatApiService
-      .post<IUserDbo>('users/init_user_record', request)
-      .pipe(share());
-    return this.initUserRecord$;
-  }
-}
-
-export interface IInitUserRecordRequest {
-  readonly authProvider?: string;
-  readonly gender?: Gender;
-  readonly ageGroup?: AgeGroupID;
-  readonly names?: IPersonNames;
-  readonly email?: string;
-  readonly emailIsVerified?: boolean;
-  readonly ianaTimezone?: string;
-  readonly space?: { type: SpaceType; title: string };
-}

package/src/test-setup.ts

@@ -1,3 +0,0 @@
-import { setupTestEnvironment } from '@sneat/core/testing';
-
-setupTestEnvironment();

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../../tsconfig.angular.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,19 +0,0 @@
-{
-  "extends": "../../../tsconfig.lib.base.json",
-  "exclude": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/test-setup.ts",
-    "src/lib/testing/**/*"
-  ]
-}

package/tsconfig.lib.prod.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.lib.json",
-  "compilerOptions": {
-    "declarationMap": false
-  },
-  "angularCompilerOptions": {}
-}

package/tsconfig.spec.json

@@ -1,31 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../dist/out-tsc",
-    "types": [
-      "vitest/globals",
-      "vitest/importMeta",
-      "vite/client",
-      "node",
-      "vitest"
-    ]
-  },
-  "include": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/**/*.d.ts"
-  ],
-  "files": [
-    "src/test-setup.ts"
-  ]
-}

package/vite.config.mts

@@ -1,10 +0,0 @@
-/// <reference types='vitest' />
-import { defineConfig } from 'vitest/config';
-import { createBaseViteConfig } from '../../../vite.config.base';
-
-export default defineConfig(() =>
-	createBaseViteConfig({
-		dirname: __dirname,
-		name: 'auth-core',
-	}),
-);