@lifeready/core 1.0.1 → 1.0.2

package/src/lib/auth/idle.service.spec.ts

@@ -1,119 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import {
-  loginTestUser,
-  logoutUser,
-} from '../auth/life-ready-auth.service.spec';
-import { delaySec, lrConfigureTestingModule, lrit } from '../_common/tests';
-import { IdleService } from 'projects/core/src/lib/auth/idle.service';
-import { KeyService } from '../cryptography/key.service';
-import { PersistService } from 'projects/core/src/lib/api/persist.service';
-
-const TIMEOUT = 1000 * 60 * 10;
-
-describe('IdleService', () => {
-  let idleService: IdleService;
-  let keyService: KeyService;
-  let persistService: PersistService;
-
-  beforeEach(async () => {
-    lrConfigureTestingModule();
-
-    idleService = TestBed.inject(IdleService);
-    keyService = TestBed.inject(KeyService);
-    persistService = TestBed.inject(PersistService);
-  }, TIMEOUT);
-
-  lrit(
-    'should be created',
-    () => {
-      expect(idleService).toBeTruthy();
-    },
-    TIMEOUT
-  );
-
-  // The keyService.getMasterKey() returns the memory caches lastKey. So we need
-  // to test directly against the persistService.
-  async function expectMasterKey() {
-    const value = await persistService.get(
-      (keyService as any).STORE_MASTER_KEY
-    );
-    expect(value.jwk).toBeTruthy();
-  }
-
-  async function expectNoMasterKey() {
-    const value = await persistService.get(
-      (keyService as any).STORE_MASTER_KEY
-    );
-    expect(value).not.toBeTruthy();
-  }
-
-  async function shouldDetectIdle() {
-    let timeoutCalled = 0;
-    let keepaliveCalled = 0;
-    const onTimeout = () => {
-      console.log('onTimeout() called');
-      ++timeoutCalled;
-    };
-
-    const onKeepalive = () => {
-      console.log('onKeepalive() called');
-      ++keepaliveCalled;
-    };
-
-    const idleSec = 3;
-    const keepAliveIntervalSec = 0.5;
-    const timeoutSec = 2;
-
-    // The default expiry is 20 minutes. Too long for this test.
-    // setting UseServerSessionExpiry to false will let is use:
-    // (idleSec + keepAliveIntervalSec + timeoutSec) as the session expiry
-    // for the passKey.
-    await idleService.init({
-      idleSec,
-      keepAliveIntervalSec,
-      timeoutSec,
-      onTimeout,
-      onKeepalive,
-    });
-
-    await logoutUser();
-    const user = await loginTestUser();
-    const { expiresAfterSeconds } = await idleService.keepalivePost();
-    console.log('expiresAfterSeconds: ', expiresAfterSeconds);
-
-    await expectMasterKey();
-
-    await delaySec(idleSec / 2);
-    // Should still be under the idle threshold
-    await expectMasterKey();
-
-    await delaySec(idleSec - idleSec / 2);
-    // Idle should start, this is when it should stops sending keep alive pings.
-    await expectMasterKey();
-    // So +expiresAfterSeconds from now the passkey should expire
-    const checkExpiry = (async () => {
-      await delaySec(expiresAfterSeconds);
-      await delaySec(1); // add some buffer just to be sure
-
-      expect(timeoutCalled).toEqual(1);
-      expect(keepaliveCalled).toBeGreaterThan(1);
-
-      await expectNoMasterKey();
-    })();
-
-    await delaySec(timeoutSec);
-    // Should be idling now.
-    await expectMasterKey();
-
-    return checkExpiry;
-  }
-
-  lrit(
-    'should detect idle',
-    async () => {
-      // Run in twice to make sure it's repeatable after login.
-      await shouldDetectIdle();
-    },
-    TIMEOUT
-  );
-});

package/src/lib/auth/idle.service.ts

@@ -1,208 +0,0 @@
-import { Inject, Injectable } from '@angular/core';
-import { Idle, DEFAULT_INTERRUPTSOURCES } from '@ng-idle/core';
-import { Keepalive } from '@ng-idle/keepalive';
-import { KeyService } from '../cryptography/key.service';
-import {
-  LrBadArgumentException,
-  LrBadStateException,
-} from '../_common/exceptions';
-import { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';
-import { HttpClient } from '@angular/common/http';
-import { Config, KeepaliveResult } from './idle.types';
-import { Key } from '../cryptography/cryptography.types';
-import { CognitoUser } from '@aws-amplify/auth';
-import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
-
-export interface IdleServiceInit {
-  // TODO: this should be EventEmitter instead of a callback.
-  onTimeout?: (() => any) | (() => Promise<any>) | null;
-  onKeepalive?: (() => any) | (() => Promise<any>) | null;
-  idleSec?: number;
-  timeoutSec?: number;
-  keepAliveIntervalSec?: number;
-}
-
-@Injectable({
-  providedIn: 'root',
-})
-export class IdleService {
-  private readonly IDLE_EXPIRY_KEY = 'ng2Idle.main.expiry';
-  private readonly IDLING_KEY = 'ng2Idle.main.idling';
-
-  private initCalled = false;
-  private onTimeout: (() => any) | (() => Promise<any>) | null;
-  private onKeepalive: (() => any) | (() => Promise<any>) | null;
-
-  constructor(
-    @Inject(LR_CONFIG) private config: LifeReadyConfig,
-    private http: HttpClient,
-    private idle: Idle,
-    private keepalive: Keepalive,
-    private keyService: KeyService,
-    private auth: AuthClass
-  ) {}
-
-  private assertInit(): void {
-    if (!this.initCalled) {
-      throw new LrBadStateException('Call IdleService.init() first.');
-    }
-  }
-
-  public async init(params?: IdleServiceInit): Promise<void> {
-    if (this.initCalled) {
-      throw new LrBadStateException(
-        'IdleService.init() can only be called once. IdleService.start() calls init() with default values if init() has not been called yet.'
-      );
-    }
-
-    this.initCalled = true;
-
-    // Defaults
-    params = {
-      onTimeout: null,
-      onKeepalive: null,
-      idleSec: Config.IDLE,
-      timeoutSec: Config.TIMEOUT,
-      keepAliveIntervalSec: Config.KEEP_ALIVE_INTERVAL,
-      ...params,
-    };
-
-    // If timeoutSec == 0 then the onTimeout() callback is never called.
-    if (params.timeoutSec < 0.01) {
-      throw new LrBadArgumentException(
-        'Minimum value for IdleService.init({ timeoutSec }) is 0.01'
-      );
-    }
-
-    this.onTimeout = params.onTimeout;
-    this.onKeepalive = params.onKeepalive;
-
-    // ------------------------------------------------------------------------
-    // Setup Idle
-    // ------------------------------------------------------------------------
-    // sets an idle timeout of 5 seconds, for testing purposes.
-    this.idle.setIdle(params.idleSec);
-    // sets a timeout period of 5 seconds. after 10 seconds of inactivity, the user will be considered timed out.
-    this.idle.setTimeout(params.timeoutSec);
-    // sets the default interrupts, in this case, things like clicks, scrolls, touches to the document
-    this.idle.setInterrupts(DEFAULT_INTERRUPTSOURCES);
-
-    this.idle.onIdleEnd.subscribe(() => console.log('Idle stopped'));
-    this.idle.onIdleStart.subscribe(() => console.log('Idle started'));
-
-    this.idle.onTimeout.subscribe(async () => {
-      console.log('Idle timed out');
-      this.reset();
-      await Promise.resolve(this.onTimeout && this.onTimeout());
-    });
-    this.idle.onTimeoutWarning.subscribe((countdown: any) =>
-      console.log(`Will timeout in ${countdown} seconds!`)
-    );
-
-    // ------------------------------------------------------------------------
-    // Setup Keepalive
-    // ------------------------------------------------------------------------
-    // Ref: https://github.com/moribvndvs/ng2-idle#readme
-    // ng-idle will instruct @ng-idle/keepalive to ping while the user is active, and stop once
-    // they go idle or time out. When the user resumes activity or the idle state is reset, it will
-    // ping immediately and then resume pinging.
-    this.keepalive.interval(params.keepAliveIntervalSec);
-    console.log(
-      `Keep alive interval set at: ${Config.KEEP_ALIVE_INTERVAL} seconds`
-    );
-
-    this.keepalive.onPing.subscribe(() => this.onPing());
-
-    // If the browser tab has been closed for a period longer thant the inactivity
-    // period, then we should logout right from the start.
-    const idleExpiry = localStorage.getItem(this.IDLE_EXPIRY_KEY);
-    if (
-      idleExpiry &&
-      parseInt(idleExpiry, 10) + this.idle.getTimeout() * 1000 < Date.now()
-    ) {
-      this.reset();
-      await Promise.resolve(this.onTimeout && this.onTimeout());
-    }
-  }
-
-  public async keepalivePost(): Promise<{
-    expiresAfterSeconds: number;
-    keepaliveResult: KeepaliveResult;
-  }> {
-    // currentAuthenticatedUser() refreshes the access token if required.
-    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();
-
-    const keepaliveResult = await this.http
-      .post<KeepaliveResult>(`${this.config.authUrl}auth/keepalive/`, null, {
-        withCredentials: true, // /auth/keepalive/ will be extending the sessions cookie.
-        headers: {
-          Authorization: `Bearer ${cognitoUser
-            .getSignInUserSession()
-            .getAccessToken()
-            .getJwtToken()}`,
-        },
-      })
-      .toPromise();
-
-    return {
-      keepaliveResult,
-      expiresAfterSeconds:
-        this.idle.getIdle() +
-        this.idle.getTimeout() +
-        this.keepalive.interval(),
-    };
-  }
-
-  public async persistMasterKey(masterKey: Key): Promise<void> {
-    // The keepalive API call extends the server-side session, the session cookie expiry, refresh key cookie
-    // expiry, and returns the session expiry.
-    // NOTE Use time delta rather than absolute time, since client clock and server clock maybe
-    // out of sync. We can't use the serverTime() functionality because the cookie expiry still
-    // run on local clock.
-    const { expiresAfterSeconds } = await this.keepalivePost();
-
-    // Persist the derived passKey
-    await this.keyService.persistMasterKey(masterKey, expiresAfterSeconds);
-
-    console.log('setMasterKey() done');
-  }
-
-  private async onPing(): Promise<void> {
-    console.log(
-      `Keep alive triggered at time: ${Date.now()}. Interval set at: ${this.keepalive.interval()} seconds`
-    );
-
-    // Keepalive API will extend the session expiry.
-    const { expiresAfterSeconds } = await this.keepalivePost();
-
-    // Extend the expiry of the persisted key
-    await this.keyService.setMasterKeyExpiresAfterSeconds(expiresAfterSeconds);
-
-    await Promise.resolve(this.onKeepalive && this.onKeepalive());
-  }
-
-  public async start(): Promise<void> {
-    if (!this.initCalled) {
-      await this.init();
-    }
-
-    if (this.idle.isRunning()) {
-      return;
-    }
-
-    // Ping does not seem to happen right at the start. So we call it explicitly
-    await this.onPing();
-
-    this.idle.watch();
-  }
-
-  public stop(): void {
-    this.idle.stop();
-    this.reset();
-  }
-
-  private reset() {
-    localStorage.removeItem(this.IDLE_EXPIRY_KEY);
-    localStorage.removeItem(this.IDLING_KEY);
-  }
-}

package/src/lib/auth/idle.types.ts

@@ -1,11 +0,0 @@
-export enum Config {
-  TIMEOUT = 0.01, // seconds, min value 0.01, after state is idle, wait for TIMEOUT seconds before taking action
-  IDLE = 60 * 20, // seconds, period of inactivity to consider state as idle
-  KEEP_ALIVE_INTERVAL = 60 * 1, // seconds, triggered on a regular basis while active (i.e. while not idling)
-}
-
-export interface KeepaliveResult {
-  session: {
-    expires_after_seconds: number;
-  };
-}

package/src/lib/auth/lbop.service.spec.ts

@@ -1,56 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { loginTestUser } from '../auth/life-ready-auth.service.spec';
-import { LbopService } from './lbop.service';
-import { CurrentUser } from '../../public-api';
-import { lrConfigureTestingModule, lrit } from '../_common/tests';
-
-const TIMEOUT = 1000 * 60 * 10;
-
-describe('LbopService', () => {
-  let lbopService: LbopService;
-  let user: CurrentUser;
-
-  beforeEach(async () => {
-    lrConfigureTestingModule();
-    lbopService = TestBed.inject(LbopService);
-    user = await loginTestUser();
-  }, TIMEOUT);
-
-  lrit(
-    'should be created',
-    () => {
-      expect(lbopService).toBeTruthy();
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'should CRUD lbop',
-    async () => {
-      if (!user) return;
-
-      const lbopsBefore = await lbopService.list();
-      const lbop1 = await lbopService.create({ name: 'abc' });
-      const lbop2 = await lbopService.create({ name: 'abc' });
-      const lbopsAfterCreate = await lbopService.list();
-
-      expect(lbop1.id).not.toBe(
-        lbop2.id,
-        'the server should allow same name because it is encrypted.'
-      );
-      expect(lbopsAfterCreate.length).toBe(lbopsBefore.length + 2);
-
-      await lbopService.remove(lbop1.id);
-
-      const lbopsAfterDelete = await lbopService.list();
-      expect(lbopsAfterDelete.length).toBe(lbopsAfterCreate.length - 1);
-
-      // Make sure it's been deleted.
-      expect(lbopsAfterDelete.some((t) => t.id === lbop1.id)).toBeFalsy();
-
-      await lbopService.update({ id: lbop2.id, name: '123' });
-      expect((await lbopService.get(lbop2.id)).name).toBe('123');
-    },
-    TIMEOUT
-  );
-});