@sneat/auth-core 0.1.3 → 0.1.6

package/project.json

@@ -1,38 +0,0 @@
-{
-  "name": "auth-core",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "projectType": "library",
-  "sourceRoot": "libs/auth/core/src",
-  "prefix": "sneat",
-  "targets": {
-    "build": {
-      "executor": "@nx/angular:ng-packagr-lite",
-      "outputs": [
-        "{workspaceRoot}/dist/libs/auth/core"
-      ],
-      "options": {
-        "project": "libs/auth/core/ng-package.json",
-        "tsConfig": "libs/auth/core/tsconfig.lib.json"
-      },
-      "configurations": {
-        "production": {
-          "tsConfig": "libs/auth/core/tsconfig.lib.prod.json"
-        },
-        "development": {}
-      },
-      "defaultConfiguration": "production"
-    },
-    "test": {
-      "executor": "@nx/vitest:test",
-      "outputs": [
-        "{workspaceRoot}/coverage/libs/auth/core"
-      ],
-      "options": {
-        "tsConfig": "libs/auth/core/tsconfig.spec.json"
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    }
-  }
-}

package/src/lib/login-required-service.service.spec.ts

@@ -1,39 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { LoginRequiredServiceService } from './login-required-service.service';
-import { SneatAuthStateService } from './sneat-auth-state-service';
-import { of } from 'rxjs';
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-describe('LoginRequiredServiceService', () => {
-  let authStateMock: { authState: ReturnType<typeof of> };
-
-  beforeEach(() => {
-    authStateMock = {
-      authState: of({
-        status: 'authenticated',
-        user: { uid: 'test-uid', email: 'test@example.com' },
-      }),
-    };
-
-    TestBed.configureTestingModule({
-      providers: [
-        LoginRequiredServiceService,
-        {
-          provide: SneatAuthStateService,
-          useValue: authStateMock,
-        },
-      ],
-    });
-  });
-
-  it('should be created', () => {
-    const service = TestBed.inject(LoginRequiredServiceService);
-    expect(service).toBeTruthy();
-  });
-
-  it('should subscribe to auth state changes', () => {
-    const subscribeSpy = vi.spyOn(authStateMock.authState, 'subscribe');
-    TestBed.inject(LoginRequiredServiceService);
-    expect(subscribeSpy).toHaveBeenCalled();
-  });
-});

package/src/lib/login-required-service.service.ts

@@ -1,14 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import { SneatAuthStateService } from './sneat-auth-state-service';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class LoginRequiredServiceService {
-  constructor() {
-    const authState = inject(SneatAuthStateService);
-    authState.authState.subscribe(() => {
-      // Intentionally empty - just subscribing to trigger the observable
-    });
-  }
-}

package/src/lib/private-token-store.service.spec.ts

@@ -1,75 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import {
-  PrivateTokenStoreService,
-  canceledByUser,
-} from './private-token-store.service';
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { firstValueFrom } from 'rxjs';
-
-describe('PrivateTokenStoreService', () => {
-  let service: PrivateTokenStoreService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [PrivateTokenStoreService],
-    });
-    service = TestBed.inject(PrivateTokenStoreService);
-    localStorage.clear();
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  it('should return token from localStorage if available', async () => {
-    const domain = 'test.com';
-    const projectId = 'proj123';
-    const token = 'stored-token-123';
-
-    localStorage.setItem(`private/tokens/${domain}/${projectId}`, token);
-
-    const result = await firstValueFrom(
-      service.getPrivateToken(domain, projectId),
-    );
-    expect(result).toBe(token);
-  });
-
-  it('should prompt user for token if not in localStorage', async () => {
-    const domain = 'test.com';
-    const projectId = 'proj456';
-    const token = 'new-token-456';
-
-    // Mock the global prompt function
-    globalThis.prompt = vi.fn().mockReturnValue(token);
-
-    const promise = firstValueFrom(service.getPrivateToken(domain, projectId));
-
-    await new Promise((resolve) => setTimeout(resolve, 10));
-
-    const result = await promise;
-    expect(result).toBe(token);
-    expect(localStorage.getItem(`private/tokens/${domain}/${projectId}`)).toBe(
-      token,
-    );
-
-    // Cleanup
-    delete (globalThis as { prompt?: unknown }).prompt;
-  });
-
-  it('should error with canceledByUser if user cancels prompt', async () => {
-    const domain = 'test.com';
-    const projectId = 'proj789';
-
-    // Mock the global prompt function
-    globalThis.prompt = vi.fn().mockReturnValue(null);
-
-    const promise = firstValueFrom(service.getPrivateToken(domain, projectId));
-
-    await new Promise((resolve) => setTimeout(resolve, 10));
-
-    await expect(promise).rejects.toBe(canceledByUser);
-
-    // Cleanup
-    delete (globalThis as { prompt?: unknown }).prompt;
-  });
-});

package/src/lib/private-token-store.service.ts

@@ -1,36 +0,0 @@
-import { Injectable } from '@angular/core';
-import { Observable, of, Subject } from 'rxjs';
-
-const tokenKey = (domain: string, projectId: string) =>
-  `private/tokens/${domain}/${projectId}`;
-
-export const canceledByUser = 'canceled by user';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class PrivateTokenStoreService {
-  public getPrivateToken(
-    domain: string,
-    projectId: string,
-  ): Observable<string> {
-    // Consider storing all tokens in a single item
-    const key = tokenKey(domain, projectId);
-    let token = localStorage.getItem(key);
-    if (token) {
-      return of(token);
-    }
-
-    const subj = new Subject<string>();
-    setTimeout(() => {
-      token = prompt(`Please provide access token for ${domain}:`);
-      if (token) {
-        localStorage.setItem(key, token);
-        subj.next(token);
-      } else {
-        subj.error(canceledByUser);
-      }
-    }, 1);
-    return subj.asObservable();
-  }
-}

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

@@ -1,124 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import {
-  Router,
-  Route,
-  UrlSegment,
-  ActivatedRouteSnapshot,
-  RouterStateSnapshot,
-} from '@angular/router';
-import { Auth } from '@angular/fire/auth';
-import {
-  SneatAuthGuard,
-  redirectToLoginIfNotSignedIn,
-} from './sneat-auth-guard';
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { of, firstValueFrom } from 'rxjs';
-
-describe('SneatAuthGuard', () => {
-  let guard: SneatAuthGuard;
-  let routerMock: {
-    createUrlTree: ReturnType<typeof vi.fn>;
-    parseUrl: ReturnType<typeof vi.fn>;
-  };
-
-  beforeEach(() => {
-    routerMock = {
-      createUrlTree: vi.fn(),
-      parseUrl: vi.fn(),
-    };
-
-    TestBed.configureTestingModule({
-      providers: [
-        SneatAuthGuard,
-        { provide: Router, useValue: routerMock },
-        {
-          provide: Auth,
-          useValue: {},
-        },
-      ],
-    });
-
-    guard = TestBed.inject(SneatAuthGuard);
-  });
-
-  it('should be created', () => {
-    expect(guard).toBeTruthy();
-  });
-
-  describe('canLoad', () => {
-    it('should return true', () => {
-      const route: Route = { path: 'test' };
-      const segments: UrlSegment[] = [];
-
-      const result = guard.canLoad(route, segments);
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('canActivate', () => {
-    it('should return true', () => {
-      const route = {} as ActivatedRouteSnapshot;
-      const state = { url: '/test' } as RouterStateSnapshot;
-
-      const result = guard.canActivate(route, state);
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('canActivateChild', () => {
-    it('should return true', () => {
-      const childRoute = {} as ActivatedRouteSnapshot;
-      const state = { url: '/test/child' } as RouterStateSnapshot;
-
-      const result = guard.canActivateChild(childRoute, state);
-      expect(result).toBe(true);
-    });
-  });
-});
-
-describe('redirectToLoginIfNotSignedIn', () => {
-  it('should return true for authenticated user', async () => {
-    const user = { uid: 'test-uid' };
-
-    const result = await firstValueFrom(
-      of(user).pipe(redirectToLoginIfNotSignedIn),
-    );
-    expect(result).toBe(true);
-  });
-
-  it('should return login URL for unauthenticated user at root', async () => {
-    const originalPathname = location.pathname;
-    Object.defineProperty(window.location, 'pathname', {
-      writable: true,
-      value: '/',
-    });
-
-    const result = await firstValueFrom(
-      of(null).pipe(redirectToLoginIfNotSignedIn),
-    );
-    expect(result).toBe('/login');
-
-    Object.defineProperty(window.location, 'pathname', {
-      writable: true,
-      value: originalPathname,
-    });
-  });
-
-  it('should return login URL with hash for unauthenticated user at non-root path', async () => {
-    const originalPathname = location.pathname;
-    Object.defineProperty(window.location, 'pathname', {
-      writable: true,
-      value: '/protected',
-    });
-
-    const result = await firstValueFrom(
-      of(null).pipe(redirectToLoginIfNotSignedIn),
-    );
-    expect(result).toBe('/login#/protected');
-
-    Object.defineProperty(window.location, 'pathname', {
-      writable: true,
-      value: originalPathname,
-    });
-  });
-});

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

@@ -1,107 +0,0 @@
-import {
-  ActivatedRouteSnapshot,
-  // CanActivate,
-  // CanActivateChild,
-  // CanLoad,
-  Route,
-  Router,
-  RouterStateSnapshot,
-  UrlSegment,
-  UrlTree,
-} from '@angular/router';
-import { Observable } from 'rxjs';
-import { Injectable, inject } from '@angular/core';
-import { Auth } from '@angular/fire/auth';
-import { map } from 'rxjs/operators';
-import { AuthPipe } from '@angular/fire/auth-guard';
-
-type AuthCanLoadPipeGenerator = (
-  route: Route,
-  segments: UrlSegment[],
-) => AuthPipe;
-
-export const redirectToLoginIfNotSignedIn: AuthPipe = map((user) => {
-  if (user) {
-    return true;
-  }
-  let url = '/login';
-  if (location.pathname != '/') {
-    url += '#' + location.pathname;
-  }
-  return url;
-});
-
-@Injectable({
-  providedIn: 'root',
-})
-export class SneatAuthGuard /*implements CanLoad, CanActivate, CanActivateChild*/ {
-  private readonly router = inject(Router);
-  private readonly auth = inject(Auth);
-
-  public canLoad(
-    _route: Route,
-    _segments: UrlSegment[],
-  ):
-    | Observable<boolean | UrlTree>
-    | Promise<boolean | UrlTree>
-    | boolean
-    | UrlTree {
-    {
-      // console.log('SneatAuthGuard.canLoad', route, segments);
-      // const authPipeFactory =
-      // 	(route.data && route.data['authCanLoadGuardPipe'] as AuthCanLoadPipeGenerator) ||
-      // 	(() => redirectToLoginIfNotSignedIn);
-      // const subj = new Subject<boolean>();
-      // onAuthStateChanged(this.auth, {
-      // 	next: (user) => {
-      // 		console.log('onAuthStateChanged', user);
-      // 	}
-      // })
-      // return this.auth.user.pipe(
-      // 	map((user) => {
-      // 		console.log('user', user);
-      // 		return user;
-      // 	}),
-      // 	take(1),
-      // 	authPipeFactory(route, segments),
-      // 	map((can) => {
-      // 		console.log('can', can);
-      // 		if (typeof can === 'boolean') {
-      // 			return can;
-      // 		} else if (Array.isArray(can)) {
-      // 			return this.router.createUrlTree(can);
-      // 		} else {
-      // 			return this.router.parseUrl(can);
-      // 		}
-      // 	}),
-      // );
-      return true;
-    }
-  }
-
-  public canActivate(
-    _route: ActivatedRouteSnapshot,
-    _state: RouterStateSnapshot, //: Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree
-  ) {
-    // console.log('SneatAuthGuard.canActivate', route, state);
-    return true;
-  }
-
-  canActivateChild(
-    _childRoute: ActivatedRouteSnapshot,
-    _state: RouterStateSnapshot, // : Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree
-  ) {
-    // console.log('SneatAuthGuard.canActivateChild', childRoute, state);
-    return true;
-  }
-}
-
-export const canLoad = (pipe?: AuthCanLoadPipeGenerator) => ({
-  canLoad: [SneatAuthGuard],
-  data: { authCanLoadGuardPipe: pipe },
-});
-
-export const SNEAT_AUTH_GUARDS = {
-  canActivate: [SneatAuthGuard],
-  canLoad: [SneatAuthGuard],
-};