@peassoft/mnr-web-topline 0.1.0

package/dist/ru/modules/local-db/init-db.d.ts

@@ -0,0 +1,17 @@
+export declare const STORE_NAME = "main";
+/**
+ * Get IndexedDb database object
+ *
+ * Returns null if database initialization has failed.
+ *
+ * @public
+ */
+export declare function getDb(): IDBDatabase | null;
+/**
+ * Initialize local database
+ *
+ * @throws {LocalDbInitializationError}
+ *
+ * @public
+ */
+export declare function initDb(): Promise<void>;

package/dist/ru/modules/local-db/init-db.js

@@ -0,0 +1,52 @@
+import WebError from '@memnrev/web-error';
+const DB_NAME = 'mnr_topline';
+const DB_VERSION = 1;
+export const STORE_NAME = 'main';
+let _db = null;
+/**
+ * Get IndexedDb database object
+ *
+ * Returns null if database initialization has failed.
+ *
+ * @public
+ */
+export function getDb() {
+  return _db;
+}
+/**
+ * Initialize local database
+ *
+ * @throws {LocalDbInitializationError}
+ *
+ * @public
+ */
+export function initDb() {
+  return new Promise((resolve, reject) => {
+    const openDbReq = window.indexedDB.open(DB_NAME, DB_VERSION);
+    openDbReq.onerror = function (_e) {
+      reject(new WebError({
+        name: 'LocalDbInitializationError'
+      }, 'opening local database failed'));
+    };
+    openDbReq.onsuccess = function () {
+      _db = this.result;
+      resolve();
+    };
+    openDbReq.onupgradeneeded = function (e) {
+      if (e.oldVersion < DB_VERSION) {
+        const db = this.result;
+        for (const objectStoreName of db.objectStoreNames) {
+          db.deleteObjectStore(objectStoreName);
+        }
+        db.createObjectStore(STORE_NAME, {
+          keyPath: 'entityType'
+        });
+      }
+    };
+    openDbReq.onblocked = function () {
+      reject(new WebError({
+        name: 'LocalDbInitializationError'
+      }, 'failed upgrading local database due to it is blocked'));
+    };
+  });
+}

package/dist/ru/modules/logger/index.d.ts

@@ -0,0 +1 @@
+export declare function logError(err: Error): void;

package/dist/ru/modules/logger/index.js

@@ -0,0 +1,3 @@
+export function logError(err) {
+  console.error(err);
+}

package/dist/ru/modules/request/index.d.ts

@@ -0,0 +1,20 @@
+import type { CustomRequestOptions, CustomResponse } from './types.js';
+export type { CustomRequestOptions, CustomResponse } from './types.js';
+/**
+ * Make request.
+ *
+ * Returns `null` when:
+ *   - request is aborted due to timeout;
+ *   - request fails due to a network error;
+ *   - last retried request (or original request if retries are explicitly switched off
+ *     by `requestOpts`) responds with 5xx status code;
+ *   - original or retried request responds with a status code <500 other than that found
+ *     in `requestOpts.expectedStatusCodes`.
+ *
+ * All errors are caught and logged.
+ *
+ * @param url Full URL
+ * @param fetchApiOpts Fetch API options
+ * @param requestOpts Custom options
+ */
+export default function request(url: string, fetchApiOpts: Partial<RequestInit>, requestOpts?: CustomRequestOptions): Promise<CustomResponse | null>;

package/dist/ru/modules/request/index.js

@@ -0,0 +1,78 @@
+import WebError from '@memnrev/web-error';
+import normalizeRequestOpts from './normalize-request-opts.js';
+import { logError } from '../logger/index.js';
+import shouldRetry from './should-retry.js';
+/**
+ * Make request.
+ *
+ * Returns `null` when:
+ *   - request is aborted due to timeout;
+ *   - request fails due to a network error;
+ *   - last retried request (or original request if retries are explicitly switched off
+ *     by `requestOpts`) responds with 5xx status code;
+ *   - original or retried request responds with a status code <500 other than that found
+ *     in `requestOpts.expectedStatusCodes`.
+ *
+ * All errors are caught and logged.
+ *
+ * @param url Full URL
+ * @param fetchApiOpts Fetch API options
+ * @param requestOpts Custom options
+ */
+export default async function request(url, fetchApiOpts) {
+  let requestOpts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const {
+    expectedStatusCodes,
+    timeoutMs,
+    maxRetries,
+    retryDelayMs
+  } = normalizeRequestOpts(requestOpts);
+  const abortController = new AbortController();
+  const timer = setTimeout(() => abortController.abort(), timeoutMs);
+  let response = null;
+  try {
+    response = await window.fetch(url, {
+      ...fetchApiOpts,
+      signal: abortController.signal
+    });
+  } catch (e) {
+    if (e instanceof Error) {
+      if (e.name === 'AbortError') {
+        logError(new WebError({
+          name: 'RequestError'
+        }, `request to ${url} was aborted due to timeout`));
+      } else {
+        logError(new WebError({
+          name: 'RequestError',
+          cause: e
+        }, `request to ${url} failed`));
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response) return null;
+  if (expectedStatusCodes.includes(response.status)) {
+    return response;
+  }
+  const responseAllowsRetry = await shouldRetry(response);
+  if (responseAllowsRetry && maxRetries > 0) {
+    await new Promise(resolve => {
+      setTimeout(resolve, retryDelayMs);
+    });
+    return await request(url, fetchApiOpts, {
+      ...requestOpts,
+      maxRetries: maxRetries - 1
+    });
+  }
+  if (response.status >= 500 && response.status < 600) {
+    logError(new WebError({
+      name: 'ServiceUnavailable'
+    }, `request to ${url} failed with ${response.status} status code`));
+    return null;
+  }
+  logError(new WebError({
+    name: 'UnexpectedError'
+  }, `request to ${url} returned unexpected status code ${response.status}`));
+  return null;
+}

package/dist/ru/modules/request/normalize-request-opts.d.ts

@@ -0,0 +1,5 @@
+import type { CustomRequestOptions } from './types.js';
+/**
+ * Normalize custom request options
+ */
+export default function normalizeRequestOpts(requestOpts: CustomRequestOptions): Required<CustomRequestOptions>;

package/dist/ru/modules/request/normalize-request-opts.js

@@ -0,0 +1,11 @@
+/**
+ * Normalize custom request options
+ */
+export default function normalizeRequestOpts(requestOpts) {
+  return {
+    expectedStatusCodes: requestOpts.expectedStatusCodes || [200, 401],
+    timeoutMs: requestOpts.timeoutMs || 15000,
+    maxRetries: requestOpts.maxRetries || 0,
+    retryDelayMs: requestOpts.retryDelayMs || 3000
+  };
+}

package/dist/ru/modules/request/should-retry.d.ts

@@ -0,0 +1,6 @@
+import type { CustomResponse } from './index.js';
+export declare const RETRIABLE_STATUSES: [number, number];
+/**
+ * Determine whether request should be retried
+ */
+export default function shouldRetry(response: CustomResponse): Promise<boolean>;

package/dist/ru/modules/request/should-retry.js

@@ -0,0 +1,16 @@
+import { isObject } from '../../types/helpers.js';
+export const RETRIABLE_STATUSES = [503, 504];
+/**
+ * Determine whether request should be retried
+ */
+export default async function shouldRetry(response) {
+  if (!RETRIABLE_STATUSES.includes(response.status)) {
+    return false;
+  }
+  try {
+    const body = await response.json();
+    return isObject(body) && 'retry' in body && body.retry === true;
+  } catch {
+    return false;
+  }
+}

package/dist/ru/modules/request/types.d.ts

@@ -0,0 +1,20 @@
+export type CustomRequestOptions = {
+    /**
+     * An array of response status codes which the caller expects and wishes to process by
+     * themselves. If not passed, defaults to `[200, 401]`.
+     */
+    expectedStatusCodes?: number[];
+    /**
+     * Request timeout in milliseconds. If not passed, defaults to 15000 ms.
+     */
+    timeoutMs?: number;
+    /**
+     * Maximum retry attempts. If not passed, defaults to 0 (no retries).
+     */
+    maxRetries?: number;
+    /**
+     * Delay in milliseconds between retries. If not passed, defaults to 3000 ms.
+     */
+    retryDelayMs?: number;
+};
+export type CustomResponse = Pick<Response, 'status' | 'json'>;

package/dist/ru/modules/request/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ru/modules/tokens/index.d.ts

@@ -0,0 +1,4 @@
+export declare function setGrantToken(grantToken: string | null): void;
+export declare function setRefreshToken(refreshToken: string | null): void;
+export declare function getGrantToken(): string | null;
+export declare function getRefreshToken(): string | null;

package/dist/ru/modules/tokens/index.js

@@ -0,0 +1,14 @@
+let _grantToken = null;
+let _refreshToken = null;
+export function setGrantToken(grantToken) {
+  _grantToken = grantToken;
+}
+export function setRefreshToken(refreshToken) {
+  _refreshToken = refreshToken;
+}
+export function getGrantToken() {
+  return _grantToken;
+}
+export function getRefreshToken() {
+  return _refreshToken;
+}

package/dist/ru/modules/topline-service/index.d.ts

@@ -0,0 +1,24 @@
+import { type LogoutListener, type UserChangeListener, type SyncNotificationListener, ToplineEventName } from './types.js';
+export { ToplineEventName, InnerToplineEventName } from './types.js';
+export { default as innerToplineService, type InnerService } from './inner-service.js';
+/**
+ * @public
+ */
+export type ToplineService = _ToplineService;
+declare class _ToplineService {
+    #private;
+    constructor();
+    /** Get grant token */
+    grantToken(): string | null;
+    /** Upgrade grant token with refresh token */
+    upgradeGrantToken(): Promise<string | null>;
+    /** Register an event listener */
+    on(eventName: ToplineEventName.Logout, cb: LogoutListener): this;
+    on(eventName: ToplineEventName.UserChange, cb: UserChangeListener): this;
+    on(eventName: ToplineEventName.SyncNotification, cb: SyncNotificationListener): this;
+    /** Command to open logging-in form */
+    logIn(): void;
+    /** Command to open creating account form */
+    createAccount(): void;
+}
+export declare const toplineService: _ToplineService;

package/dist/ru/modules/topline-service/index.js

@@ -0,0 +1,46 @@
+import innerService from './inner-service.js';
+import { ToplineEventName, InnerToplineEventName } from './types.js';
+export { ToplineEventName, InnerToplineEventName } from './types.js';
+export { default as innerToplineService } from './inner-service.js';
+class _ToplineService {
+  #innerSrvs;
+  constructor() {
+    this.#innerSrvs = innerService;
+  }
+  /** Get grant token */
+  grantToken() {
+    return this.#innerSrvs.grantToken();
+  }
+  /** Upgrade grant token with refresh token */
+  async upgradeGrantToken() {
+    return this.#innerSrvs.upgradeGrantToken();
+  }
+  on(eventName, cb) {
+    switch (eventName) {
+      case ToplineEventName.Logout:
+        this.#innerSrvs.on(eventName, cb);
+        break;
+      case ToplineEventName.UserChange:
+        this.#innerSrvs.on(eventName, cb);
+        break;
+      case ToplineEventName.SyncNotification:
+        this.#innerSrvs.on(eventName, cb);
+        break;
+      default:
+        {
+          const _exhaustiveCheck = eventName;
+          return _exhaustiveCheck;
+        }
+    }
+    return this;
+  }
+  /** Command to open logging-in form */
+  logIn() {
+    this.#innerSrvs.emitInnerEvent(InnerToplineEventName.LogIn);
+  }
+  /** Command to open creating account form */
+  createAccount() {
+    this.#innerSrvs.emitInnerEvent(InnerToplineEventName.CreateAccount);
+  }
+}
+export const toplineService = new _ToplineService();

package/dist/ru/modules/topline-service/inner-service.d.ts

@@ -0,0 +1,45 @@
+import { getRefreshToken, setGrantToken, setRefreshToken } from '../tokens/index.js';
+import { updateGrantToken as updateGrantTokenInDb, updateRefreshToken as updateRefreshTokenInDb } from '../local-db/index.js';
+import { getApiBaseUrl } from '../env/index.js';
+import request from '../request/index.js';
+import { logError } from '../logger/index.js';
+import type { ToplineUser } from '../../types/data.js';
+import { type LogoutListener, type UserChangeListener, type SyncNotificationListener, type InnerListenerCallback, ToplineEventName, InnerToplineEventName } from './types.js';
+export type Deps = {
+    getRefreshToken: typeof getRefreshToken;
+    setGrantToken: typeof setGrantToken;
+    setRefreshToken: typeof setRefreshToken;
+    getApiBaseUrl: typeof getApiBaseUrl;
+    request: typeof request;
+    updateGrantTokenInDb: typeof updateGrantTokenInDb;
+    updateRefreshTokenInDb: typeof updateRefreshTokenInDb;
+    logError: typeof logError;
+};
+export declare class InnerService {
+    #private;
+    constructor(deps: Deps);
+    /** Get grant token */
+    grantToken(): string | null;
+    /** Register an event listener */
+    on(eventName: ToplineEventName.Logout, cb: LogoutListener): void;
+    on(eventName: ToplineEventName.UserChange, cb: UserChangeListener): void;
+    on(eventName: ToplineEventName.SyncNotification, cb: SyncNotificationListener): void;
+    /** Emit an outer event */
+    emit(eventName: ToplineEventName.Logout): void;
+    emit(eventName: ToplineEventName.UserChange, payload: ToplineUser): void;
+    emit(eventName: ToplineEventName.SyncNotification, payload: string): void;
+    /** Upgrade grant token with refresh token */
+    upgradeGrantToken(): Promise<string | null>;
+    /**
+     * Process failure to aquire grant token with refresh token, or if a logout sync
+     * message is received
+     */
+    processLogout(): void;
+    /** Update user data */
+    updateUser(user: ToplineUser): Promise<void>;
+    addInnerEventListener(eventName: InnerToplineEventName, cb: InnerListenerCallback): void;
+    removeInnerEventListener(eventName: InnerToplineEventName, cb: InnerListenerCallback): void;
+    emitInnerEvent(eventName: InnerToplineEventName): void;
+}
+declare const _default: InnerService;
+export default _default;

package/dist/ru/modules/topline-service/inner-service.js

@@ -0,0 +1,219 @@
+import WebError from '@memnrev/web-error';
+import { getGrantToken, getRefreshToken, setGrantToken, setRefreshToken } from '../tokens/index.js';
+import { deleteAllData as deleteAllDataFromDb, updateGrantToken as updateGrantTokenInDb, updateRefreshToken as updateRefreshTokenInDb, updateUser as updateUserInDb } from '../local-db/index.js';
+import { getApiBaseUrl } from '../env/index.js';
+import request from '../request/index.js';
+import { logError } from '../logger/index.js';
+import { ToplineEventName, InnerToplineEventName } from './types.js';
+import { isObject } from '../../types/helpers.js';
+export class InnerService {
+  // Dependency injection
+  #getRefreshToken;
+  #setGrantToken;
+  #setRefreshToken;
+  #getApiBaseUrl;
+  #request;
+  #updateGrantTokenInDb;
+  #updateRefreshTokenInDb;
+  #logError;
+  /** Registered outer event listeners */
+  #listeners = (() => new Set())();
+  /** Registered inner "log-in" event listeners */
+  #innerLogInListeners = (() => new Set())();
+  /** Registered inner "create-account" event listeners */
+  #innerCreateAccountListeners = (() => new Set())();
+  constructor(deps) {
+    this.#getRefreshToken = deps.getRefreshToken;
+    this.#setGrantToken = deps.setGrantToken;
+    this.#setRefreshToken = deps.setRefreshToken;
+    this.#getApiBaseUrl = deps.getApiBaseUrl;
+    this.#request = deps.request;
+    this.#updateGrantTokenInDb = deps.updateGrantTokenInDb;
+    this.#updateRefreshTokenInDb = deps.updateRefreshTokenInDb;
+    this.#logError = deps.logError;
+  }
+  /** Get grant token */
+  grantToken() {
+    return getGrantToken();
+  }
+  on(eventName, cb) {
+    switch (eventName) {
+      case ToplineEventName.Logout:
+        this.#listeners.add({
+          eventName,
+          cb: cb
+        });
+        break;
+      case ToplineEventName.UserChange:
+        this.#listeners.add({
+          eventName,
+          cb: cb
+        });
+        break;
+      case ToplineEventName.SyncNotification:
+        this.#listeners.add({
+          eventName,
+          cb: cb
+        });
+        break;
+      default:
+        {
+          const _exhaustiveCheck = eventName;
+          return _exhaustiveCheck;
+        }
+    }
+  }
+  emit(eventName, payload) {
+    this.#listeners.forEach(listener => {
+      if (eventName === listener.eventName) {
+        switch (listener.eventName) {
+          case ToplineEventName.Logout:
+            listener.cb.call(this);
+            break;
+          case ToplineEventName.UserChange:
+            listener.cb.call(this, payload);
+            break;
+          case ToplineEventName.SyncNotification:
+            listener.cb.call(this, payload);
+            break;
+          default:
+            {
+              const _exhaustiveCheck = listener;
+              return _exhaustiveCheck;
+            }
+        }
+      }
+    });
+  }
+  /** Upgrade grant token with refresh token */
+  async upgradeGrantToken() {
+    const refreshToken = this.#getRefreshToken();
+    if (!refreshToken) {
+      this.processLogout();
+      return null;
+    }
+    const url = `${this.#getApiBaseUrl()}/public/login-with-refresh-token`;
+    const options = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8'
+      },
+      body: JSON.stringify({
+        refreshToken
+      }),
+      cache: 'no-store',
+      redirect: 'error'
+    };
+    const response = await this.#request(url, options, {
+      maxRetries: 1
+    });
+    if (!response) {
+      return null;
+    }
+    if (response.status === 200) {
+      try {
+        const responseBody = await response.json();
+        if (isObject(responseBody) && 'grantToken' in responseBody && typeof responseBody.grantToken === 'string') {
+          const {
+            grantToken
+          } = responseBody;
+          this.#setGrantToken(grantToken);
+          await this.#updateGrantTokenInDb(grantToken);
+          if ('refreshToken' in responseBody && typeof responseBody.refreshToken === 'string') {
+            this.#setRefreshToken(responseBody.refreshToken);
+            await this.#updateRefreshTokenInDb(responseBody.refreshToken);
+          }
+          return grantToken;
+        } else {
+          this.#logError(new WebError({
+            name: 'UnexpectedError'
+          }, `unexpected payload of response to request to ${url}`));
+          return null;
+        }
+      } catch (err) {
+        this.#logError(new WebError({
+          name: 'UnexpectedError',
+          cause: err
+        }, `parsing 200 response of request to ${url} failed`));
+        return null;
+      }
+    }
+    if (response.status === 401) {
+      this.processLogout();
+      return null;
+    }
+    // This code is actually unreachable as `request` returns `null` in case of unexpected
+    // status code. The code is added to preserve formal function API.
+    return null;
+  }
+  /**
+   * Process failure to aquire grant token with refresh token, or if a logout sync
+   * message is received
+   */
+  processLogout() {
+    setGrantToken(null);
+    setRefreshToken(null);
+    this.emit(ToplineEventName.Logout);
+    void deleteAllDataFromDb();
+  }
+  /** Update user data */
+  async updateUser(user) {
+    await updateUserInDb(user);
+    this.emit(ToplineEventName.UserChange, user);
+  }
+  addInnerEventListener(eventName, cb) {
+    switch (eventName) {
+      case InnerToplineEventName.LogIn:
+        this.#innerLogInListeners.add(cb);
+        break;
+      case InnerToplineEventName.CreateAccount:
+        this.#innerCreateAccountListeners.add(cb);
+        break;
+      default:
+        {
+          const _exhaustiveCheck = eventName;
+          return _exhaustiveCheck;
+        }
+    }
+  }
+  removeInnerEventListener(eventName, cb) {
+    switch (eventName) {
+      case InnerToplineEventName.LogIn:
+        this.#innerLogInListeners.delete(cb);
+        break;
+      case InnerToplineEventName.CreateAccount:
+        this.#innerCreateAccountListeners.delete(cb);
+        break;
+      default:
+        {
+          const _exhaustiveCheck = eventName;
+          return _exhaustiveCheck;
+        }
+    }
+  }
+  emitInnerEvent(eventName) {
+    switch (eventName) {
+      case InnerToplineEventName.LogIn:
+        this.#innerLogInListeners.forEach(cb => cb());
+        break;
+      case InnerToplineEventName.CreateAccount:
+        this.#innerCreateAccountListeners.forEach(cb => cb());
+        break;
+      default:
+        {
+          const _exhaustiveCheck = eventName;
+          return _exhaustiveCheck;
+        }
+    }
+  }
+}
+export default new InnerService({
+  getRefreshToken,
+  setGrantToken,
+  setRefreshToken,
+  getApiBaseUrl,
+  request,
+  updateGrantTokenInDb,
+  updateRefreshTokenInDb,
+  logError
+});

package/dist/ru/modules/topline-service/types.d.ts

@@ -0,0 +1,32 @@
+import type { ToplineUser } from '../../types/data.js';
+/**
+ * Event names emitted by ToplineService
+ *
+ * @public
+ */
+export declare enum ToplineEventName {
+    /** User has been logged out */
+    Logout = "logout",
+    /** User data changed */
+    UserChange = "userChange",
+    /** A sync notification has been received */
+    SyncNotification = "syncNotification"
+}
+export type LogoutListener = () => unknown;
+export type UserChangeListener = (user: ToplineUser) => unknown;
+export type SyncNotificationListener = (syncId: string) => unknown;
+export type ToplineEventListener = {
+    eventName: ToplineEventName.Logout;
+    cb: LogoutListener;
+} | {
+    eventName: ToplineEventName.UserChange;
+    cb: UserChangeListener;
+} | {
+    eventName: ToplineEventName.SyncNotification;
+    cb: SyncNotificationListener;
+};
+export declare enum InnerToplineEventName {
+    LogIn = "logIn",
+    CreateAccount = "createAccount"
+}
+export type InnerListenerCallback = () => unknown;

package/dist/ru/modules/topline-service/types.js

@@ -0,0 +1,19 @@
+/**
+ * Event names emitted by ToplineService
+ *
+ * @public
+ */
+export var ToplineEventName;
+(function (ToplineEventName) {
+  /** User has been logged out */
+  ToplineEventName["Logout"] = "logout";
+  /** User data changed */
+  ToplineEventName["UserChange"] = "userChange";
+  /** A sync notification has been received */
+  ToplineEventName["SyncNotification"] = "syncNotification";
+})(ToplineEventName || (ToplineEventName = {}));
+export var InnerToplineEventName;
+(function (InnerToplineEventName) {
+  InnerToplineEventName["LogIn"] = "logIn";
+  InnerToplineEventName["CreateAccount"] = "createAccount";
+})(InnerToplineEventName || (InnerToplineEventName = {}));

package/dist/ru/modules/validators/email.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Validate email address
+ */
+export default function validateEmail(email: string): boolean;

package/dist/ru/modules/validators/email.js

@@ -0,0 +1,7 @@
+import { validate } from 'email-validator';
+/**
+ * Validate email address
+ */
+export default function validateEmail(email) {
+  return validate(email);
+}

package/dist/ru/modules/validators/password-recovery-code.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Validate secret code for password recovery
+ */
+export default function validatePasswordRecoveryCode(secretCode: string): boolean;