@keiser/metrics-sdk-admin-typescript 5.0.12

package/src/apis/index.ts

@@ -0,0 +1,3 @@
+/* tslint:disable */
+/* eslint-disable */
+export * from './MetricsAdminApi';

package/src/connection.ts

@@ -0,0 +1,256 @@
+import { DecodeJWT } from './jwt'
+import { SessionError } from './error'
+import { EventDispatcher } from './event'
+import { DEFAULT_REQUEST_TIMEOUT, ConnectionEvent, ConnectionOptions, MetricsConnection, PushDataEvent, HTTPMethod, HTTPHeaders } from './runtime'
+export const JWT_TTL_LIMIT = 5000
+const MAX_TIMEOUT = 2147483647;
+
+  /** @ignore */
+const MODEL_UPDATE_ROOM_REGEX = /^sub:/
+export interface AuthenticatedResponse {
+  accessToken: string
+  refreshToken?: string
+}
+export interface SubscriptionResponse extends AuthenticatedResponse {
+  subscriptionKey: string
+}
+
+export interface AuthPrefillParams {
+  email: string
+  returnUrl: string
+  requiresElevated?: boolean
+  name?: string
+  birthday?: string
+  gender?: string
+  language?: string
+  units?: string
+  metricWeight?: number
+  bodyFatPercentage?: number
+  metricHeight?: number
+}
+
+export interface AccessTokenChangeEvent {
+  accessToken: string
+}
+
+export interface RefreshTokenChangeEvent {
+  refreshToken: string
+}
+
+export interface KioskTokenChangeEvent {
+  kioskToken: string
+}
+
+export interface StrengthMachineTokenChangeEvent {
+  accessToken: string
+}
+
+export interface JWTFacility {
+    id: number
+    licensedUntil: string
+}
+
+export interface JWTToken {
+  iss: string
+  jti: string
+  exp: number
+  type: 'access' | 'refresh' | 'kiosk' | 'machine'
+}
+
+
+export interface SessionToken extends JWTToken {
+  user: { id: number }
+  facility?: {id:number, licencedUntil: string} | null
+  facilityRole?: string | null
+}
+
+export interface AccessToken extends SessionToken {
+  type: 'access'
+}
+
+export interface RefreshToken extends SessionToken {
+  type: 'refresh'
+}
+
+export interface ModelChangeEvent {
+  id: number
+  name: string
+  mutation: 'create' | 'update' | 'delete'
+  occurredAt: number
+}
+
+interface ModelChangeEventHandler {
+  onChangeCallbacks: Set<(modelChangeEvent: ModelChangeEvent) => void>
+  onReconnectCallback: () => Promise<SubscriptionResponse>
+}
+
+export interface ModelSubscribeParameters {
+  model: string
+  id: number
+  userId?: number
+  facilityRelationshipId?: number
+  actionOverride?: string
+}
+
+export interface ListSubscribeParameters {
+  parentModel: string
+  parentId: number
+  model: string
+  actionOverride?: string
+}
+
+
+export class AuthenticatedConnection {
+    protected readonly _connection: MetricsConnection
+    private _keepAlive: boolean = true
+    private _accessToken: string = ''
+    private _refreshToken: string | null = null
+    private _accessTokenTimeout: ReturnType<typeof setTimeout> | null = null
+    private readonly _modelChangeEventHandlerMap = new Map<string, ModelChangeEventHandler>()
+    private readonly _onAccessTokenChangeEvent = new EventDispatcher<AccessTokenChangeEvent>()
+    private readonly _onRefreshTokenChangeEvent = new EventDispatcher<RefreshTokenChangeEvent>()
+  
+    constructor (params: {options?: ConnectionOptions,  keepAlive?: boolean, authenticatedResponse?: AuthenticatedResponse}) {
+      const {options, keepAlive, authenticatedResponse} = params
+      this._connection = new MetricsConnection(options)
+      this._keepAlive = keepAlive ?? true
+      this._connection.onDisposeEvent.one(() => this.close())
+      this._connection.onConnectionChangeEvent.subscribe(connectionEvent => this.handleConnectionEvent(connectionEvent))
+      this._connection.onPushDataEvent.subscribe(data => this.dispatchPushData(data))
+      if (authenticatedResponse) {
+        this.updateTokens(authenticatedResponse)
+      }
+    }
+
+    async initializeAuthenticatedSession( refreshToken: string) : Promise<AuthenticatedResponse> {
+      this.updateTokens({accessToken: refreshToken})
+      const authenticatedResponse: AuthenticatedResponse = await this.keepAccessTokenAlive();
+      return authenticatedResponse;
+    }
+  
+    private updateTokens (response: AuthenticatedResponse) {
+      this._accessToken = response.accessToken
+      this._onAccessTokenChangeEvent.dispatchAsync({ accessToken: this._accessToken })
+  
+      if (this._accessTokenTimeout !== null) {
+        clearTimeout(this._accessTokenTimeout)
+      }
+  
+      if (this._keepAlive) {
+        const tokenTTL = this.decodedAccessToken.exp * 1000 - Date.now() - JWT_TTL_LIMIT
+        if(tokenTTL < MAX_TIMEOUT ) {
+          this._accessTokenTimeout = setTimeout(() => { void this.keepAccessTokenAlive() }, tokenTTL)
+        }
+      }
+  
+      if (typeof response.refreshToken !== 'undefined') {
+        this._refreshToken = response.refreshToken
+        this._onRefreshTokenChangeEvent.dispatchAsync({ refreshToken: this._refreshToken })
+      }
+    }
+  
+    private async keepAccessTokenAlive(): Promise<AuthenticatedResponse>  {
+      if (this._keepAlive) {
+        try {
+          const response: AuthenticatedResponse = await this.authenticatedAction('auth:keepAlive', `/auth/keep-alive`, 'POST', {}, {}, {})
+          return response;
+        } catch (error) {
+  
+        }
+      }
+    }
+  
+    private handleConnectionEvent (connectionEvent: ConnectionEvent) {
+      if (connectionEvent.socketConnection) {
+        this._modelChangeEventHandlerMap.forEach(e => void e.onReconnectCallback())
+      }
+    }
+  
+    private dispatchPushData (pushData: PushDataEvent) {
+      if (MODEL_UPDATE_ROOM_REGEX.test(pushData.room)) {
+        const modelChangeEventHandler = this._modelChangeEventHandlerMap.get(pushData.room)
+        if (typeof modelChangeEventHandler !== 'undefined') {
+          modelChangeEventHandler.onChangeCallbacks.forEach(e => e(pushData.message))
+        }
+      }
+    }
+  
+    get connection () {
+      return this._connection
+    }
+  
+    get keepAlive () {
+      return this._keepAlive
+    }
+  
+    set keepAlive (value: boolean) {
+      this._keepAlive = value
+      if (!this._keepAlive && this._accessTokenTimeout !== null) {
+        clearTimeout(this._accessTokenTimeout)
+      }
+    }
+  
+    get decodedAccessToken (){
+    return DecodeJWT(this.accessToken) as AccessToken
+    }
+  
+    get accessToken () {
+      return this._accessToken
+    }
+  
+    get refreshToken () {
+      return this._refreshToken
+    }
+  
+    get onRefreshTokenChangeEvent () {
+      return this._onRefreshTokenChangeEvent.asEvent()
+    }
+  
+    get onAccessTokenChangeEvent () {
+      return this._onAccessTokenChangeEvent.asEvent()
+    }
+  
+    close () {
+      if (this._accessTokenTimeout !== null) {
+        clearTimeout(this._accessTokenTimeout)
+      }
+      this.keepAlive = false
+      this._accessToken = ''
+      this._refreshToken = null
+      this.connection.dispose()
+    }
+  
+    async authenticatedAction (action: string, route: string, method: HTTPMethod, params: Object = { }, pathParams: Object = { }, headers: HTTPHeaders) {
+      let response
+      if (this._keepAlive && this._accessTokenTimeout !== null && this.decodedAccessToken.exp * 1000 - Date.now() <= JWT_TTL_LIMIT + DEFAULT_REQUEST_TIMEOUT) {
+        clearTimeout(this._accessTokenTimeout)
+      }
+      try {
+        const authParams = { authorization: this._accessToken, ...params }
+        response = await this._connection.action(action, route, method, authParams, pathParams, headers)
+      } catch (error) {
+        if (error instanceof SessionError && this._refreshToken !== null && (DecodeJWT(this._refreshToken) as RefreshToken).exp * 1000 - Date.now() > 0) {
+          const authParams = { authorization: this._refreshToken, ...params }
+          response = await this._connection.action(action, route, method, authParams, pathParams, headers)
+        } else {
+          throw error
+        }
+      }
+      this.updateTokens(response)
+      return response
+    }
+    async action (action: string, route: string, method: HTTPMethod, params: Object = { }, pathParams: Object = { }, headers: HTTPHeaders) {
+      let response
+      
+      try {
+        response = await this._connection.action(action, route, method, params, pathParams, headers)
+      } catch (error) {
+        throw error
+      }
+      if (response.accessToken) {
+        this.updateTokens(response)
+      }
+      return response
+    }
+  
+  }

package/src/error.ts

@@ -0,0 +1,248 @@
+export interface ActionErrorProperties {
+  code?: number
+  name: string
+  message: string
+  explanation?: string
+  params?: string[]
+}
+
+export class BaseMetricsError extends Error {
+  static readonly code: number = 600
+  readonly message: string
+  readonly explanation: string
+  readonly params: string[]
+
+  constructor (errorProperties: ActionErrorProperties) {
+    super(errorProperties.name)
+    this.message = errorProperties.message ?? ''
+    this.explanation = errorProperties.explanation ?? ''
+    this.params = errorProperties.params ?? []
+  }
+
+  toString () {
+    return this.name + ': ' + this.message + (this.params?.length > 0 ? ' [' + this.params.join(', ') + ']' : '')
+  }
+
+  get code () {
+    return (this.constructor as typeof BaseMetricsError).code
+  }
+}
+
+/** @hidden */
+export function GetErrorInstance (errorProperties: ActionErrorProperties) {
+  const ErrorType = [
+    MissingParamsError,
+    UnknownActionError,
+    InvalidCredentialsError,
+    ValidationError,
+    UnknownEntityError,
+    DuplicateEntityError,
+    CSRFError,
+    UnsupportedTypeError,
+    ServerShutdownError,
+    PendingActionOverflowError,
+    DataSizeLimitError,
+    OTPTokenExpiredError,
+    UnauthorizedTokenError,
+    InvalidAuthorizationCodeError,
+    BlacklistTokenError,
+    TokenInvalidError,
+    ParseError,
+    OAuthInvalidLoginError,
+    InvalidExchangeCodeError,
+    UnauthorizedResourceError,
+    OAuthCollisionError,
+    OAuthRequestError,
+    OAuthRefreshTokenError,
+    DuplicateActionError,
+    ActionPreventedError,
+    DemoActionPreventedError,
+    SessionDataMissingError,
+    FacilityLicenseExpiredError,
+    FacilityAccessControlError,
+    UnhealthyNodeError,
+    InvalidReturnUrlError,
+    SubscribePreventedError,
+    DatabaseError
+  ].find(c => c.code === errorProperties.code)
+
+  if (typeof ErrorType !== 'undefined') {
+    return new ErrorType(errorProperties)
+  }
+
+  return new ConnectionError(errorProperties)
+}
+
+// Category Errors
+
+export class RequestError extends BaseMetricsError {
+  // For errors where the issue is in the action or parameters
+}
+
+export class SessionError extends BaseMetricsError {
+  // For errors where the issue is in the token lifecycle
+}
+
+export class ServerError extends BaseMetricsError {
+  // For errors that are a result of the server's health
+}
+
+export class ConnectionError extends BaseMetricsError {
+  // For errors that are a result of a faulty connection
+  static readonly code = 0
+}
+
+// Remote Errors
+
+export class MissingParamsError extends RequestError {
+  static readonly code = 601
+}
+
+export class UnknownActionError extends RequestError {
+  static readonly code = 602
+}
+
+export class InvalidCredentialsError extends RequestError {
+  static readonly code = 603
+}
+
+export class ValidationError extends RequestError {
+  static readonly code = 604
+}
+
+export class UnknownEntityError extends RequestError {
+  static readonly code = 605
+}
+
+export class DuplicateEntityError extends RequestError {
+  static readonly code = 606
+}
+
+export class CSRFError extends SessionError {
+  static readonly code = 607
+}
+
+export class UnsupportedTypeError extends RequestError {
+  static readonly code = 608
+}
+
+export class ServerShutdownError extends ServerError {
+  static readonly code = 609
+}
+
+export class PendingActionOverflowError extends ServerError {
+  static readonly code = 610
+}
+
+export class DataSizeLimitError extends RequestError {
+  static readonly code = 611
+}
+
+export class OTPTokenExpiredError extends RequestError {
+  static readonly code = 612
+}
+
+export class UnauthorizedTokenError extends SessionError {
+  static readonly code = 613
+}
+
+export class InvalidAuthorizationCodeError extends RequestError {
+  static readonly code = 614
+}
+
+export class BlacklistTokenError extends SessionError {
+  static readonly code = 615
+}
+
+export class TokenInvalidError extends SessionError {
+  static readonly code = 616
+}
+
+export class ParseError extends RequestError {
+  static readonly code = 617
+}
+
+export class OAuthInvalidLoginError extends RequestError {
+  static readonly code = 618
+}
+
+export class InvalidExchangeCodeError extends RequestError {
+  static readonly code = 619
+}
+
+export class UnauthorizedResourceError extends RequestError {
+  static readonly code = 620
+}
+
+export class OAuthCollisionError extends RequestError {
+  static readonly code = 621
+}
+
+export class OAuthRequestError extends RequestError {
+  static readonly code = 622
+}
+
+export class OAuthRefreshTokenError extends SessionError {
+  static readonly code = 623
+}
+
+export class DuplicateActionError extends RequestError {
+  static readonly code = 624
+}
+
+export class ActionPreventedError extends RequestError {
+  static readonly code = 625
+}
+
+export class DemoActionPreventedError extends RequestError {
+  static readonly code = 626
+}
+
+export class SessionDataMissingError extends SessionError {
+  static readonly code = 627
+}
+
+export class FacilityLicenseExpiredError extends SessionError {
+  static readonly code = 628
+}
+
+export class FacilityAccessControlError extends RequestError {
+  static readonly code = 629
+}
+
+export class UnhealthyNodeError extends ServerError {
+  static readonly code = 630
+}
+
+export class InvalidReturnUrlError extends RequestError {
+  static readonly code = 631
+}
+
+export class SubscribePreventedError extends RequestError {
+  static readonly code = 632
+}
+
+export class DatabaseError extends RequestError {
+  static readonly code = 633
+}
+
+// Local Errors
+
+export class ClientSideActionPrevented extends RequestError {
+  constructor ({ explanation }: { explanation?: string }) {
+    super({
+      name: 'InvalidGACSession',
+      message: 'is not a valid GAC session',
+      explanation
+    })
+  }
+}
+
+export class ConnectionFaultError extends ConnectionError {
+  constructor () {
+    super({
+      name: 'ConnectionFault',
+      message: 'connection to server failed'
+    })
+  }
+}