@vuu-ui/vuu-data-remote 0.13.105 → 0.13.106

package/types/LostConnectionHandler.d.ts

@@ -0,0 +1,28 @@
+import { VuuAuthenticator } from "./VuuAuthenticator";
+interface RetryOptions {
+    interval: number;
+    next: () => void;
+    remaining: number;
+}
+declare class RetryOptionsImpl implements RetryOptions {
+    private retryIntervals;
+    private ind;
+    constructor(retryIntervals: number[]);
+    next(): void;
+    get remaining(): number;
+    get interval(): number;
+}
+export declare function RetryOptions(retryIntervals: number[]): RetryOptionsImpl;
+export declare class RetryGenerator {
+    private vuuAuth;
+    private options;
+    constructor(vuuAuth: VuuAuthenticator, options: RetryOptions);
+    [Symbol.asyncIterator](): AsyncGenerator;
+}
+export declare class LostConnectionHandler {
+    private vuuAuth;
+    private retryIntervals;
+    constructor(vuuAuth: VuuAuthenticator, retryIntervals?: number[]);
+    reconnect(): Promise<void>;
+}
+export {};

package/types/VuuAuthProvider.d.ts

@@ -0,0 +1,38 @@
+export type User = {
+    userName: string;
+};
+export interface AuthProvider {
+    login: (username?: string, password?: string) => Promise<{
+        authorizations: string[];
+        token: string;
+        user: User;
+    }>;
+    logout: () => void;
+}
+/**
+ * The Vuu AuthProvider is a simple Demoware auth provider that
+ * grabs username and pasdsword from. a simple login form and
+ * exchanges these for a Vuu Token. Password is manipulated in
+ * plain text, hence not suitable for real world usage.
+ *
+ * This AuthProvider is used by the login panel, which sets
+ * user credentials in cookies.
+ * It is then used by the application itself to retrieve the
+ * credentials and login to vuu.
+ */
+export declare class VuuAuthProvider implements AuthProvider {
+    private authEndpoint;
+    constructor(authEndpoint: string);
+    login: (username?: string, password?: string) => Promise<{
+        authorizations: string[];
+        user: {
+            userName: string;
+        };
+        token: string;
+    }>;
+    private getVuuTokenWithUsernameAndPassword;
+    private clear;
+    private redirectToLoginPage;
+    private redirectToApplication;
+    logout(): void;
+}

package/types/VuuAuthenticator.d.ts

@@ -0,0 +1,21 @@
+import { ValueOf } from "@vuu-ui/vuu-utils";
+import { User, type AuthProvider } from "./VuuAuthProvider";
+export declare const VuuAuthTokenIssuePolicy: {
+    readonly BearerToken: "bearer-token";
+    readonly UsernamePassword: "username-password";
+};
+export type VuuAuthTokenIssuePolicy = ValueOf<typeof VuuAuthTokenIssuePolicy>;
+export interface VuuAuthenticatorConstructorOptions {
+    authProvider: AuthProvider;
+    authTokenIssuePolicy?: VuuAuthTokenIssuePolicy;
+    websocketUrl: string;
+}
+export declare class VuuAuthenticator {
+    private authProvider;
+    private authTokenIssuePolicy;
+    private websocketUrl;
+    constructor({ authProvider, authTokenIssuePolicy, websocketUrl, }: VuuAuthenticatorConstructorOptions);
+    private openWebsocketConnection;
+    login: () => Promise<[User, string[]] | never>;
+    logout: () => void;
+}

package/types/WebSocketConnection.d.ts

@@ -1,58 +1,41 @@
 import { WebSocketProtocol } from "@vuu-ui/vuu-data-types";
-import { VuuClientMessage, VuuServerMessage } from "@vuu-ui/vuu-protocol-types";
+import { InvalidSessionReason, InvalidTokenReason, LoginErrorMessage, VuuClientMessage, VuuServerMessage } from "@vuu-ui/vuu-protocol-types";
 import { EventEmitter } from "@vuu-ui/vuu-utils";
+export type ConnectionPhase = "initial-connection" | "post-disconnect-reconnection";
 export type ConnectingStatus = "connecting" | "reconnecting";
 export type ConnectedStatus = "connected" | "reconnected";
-export type ConnectionStatus = ConnectedStatus | "closed" | "connection-open-awaiting-session" | "disconnected" | "failed" | "inactive";
-type InternalConnectionStatus = ConnectionStatus | ConnectingStatus;
-type ReconnectAttempts = {
-    retryAttemptsTotal: number;
-    retryAttemptsRemaining: number;
-    secondsToNextRetry: number;
-};
-export interface WebSocketConnectionState<T extends InternalConnectionStatus = ConnectionStatus> extends ReconnectAttempts {
-    connectionPhase: ConnectingStatus;
-    connectionStatus: T;
-}
-export declare const isWebSocketConnectionMessage: (msg: object | WebSocketConnectionState) => msg is WebSocketConnectionState;
+export type ConnectionStatus = ConnectingStatus | ConnectedStatus | "closed" | "websocket-open" | "disconnected" | "failed" | "inactive";
+export declare const isInvalidTokenReason: (text: string) => text is InvalidTokenReason;
+export declare const isInvalidSessionReason: (text: string) => text is InvalidSessionReason;
+export declare const isWebSocketConnectionStatus: (msg: unknown) => msg is ConnectionStatus;
 export declare const isConnected: (status: ConnectionStatus) => status is ConnectedStatus;
-export type VuuServerMessageCallback = (msg: VuuServerMessage) => void;
-export type RetryLimits = {
-    connect: number;
-    reconnect: number;
+export type LoginRejectedMessage = {
+    type: "LOGIN_REJECTED";
+    reason: LoginErrorMessage;
 };
+export declare const isLoginRejectedMessage: (message: object) => message is LoginRejectedMessage;
+export type VuuServerMessageCallback = (msg: VuuServerMessage | LoginRejectedMessage) => void;
 export type WebSocketConnectionConfig = {
     url: string;
     protocols: WebSocketProtocol;
     callback: VuuServerMessageCallback;
     connectionTimeout?: number;
-    retryLimits?: RetryLimits;
-};
-export type WebSocketCloseMessage = {
-    type: "websocket-closed";
-    reason: WebSocketConnectionCloseReason;
 };
-export type WebSocketConnectionCloseReason = "failure" | "shutdown" | "invalid-token" | "token-expired";
+export type WebSocketConnectionCloseReason = LoginErrorMessage | "failure" | "shutdown";
 export type WebSocketConnectionEvents = {
-    closed: (message: WebSocketCloseMessage) => void;
-    connected: () => void;
-    "connection-status": (message: WebSocketConnectionState) => void;
-    reconnected: () => void;
+    "connection-status": (status: ConnectionStatus) => void;
 };
 export declare class WebSocketConnection extends EventEmitter<WebSocketConnectionEvents> {
     #private;
-    constructor({ callback, connectionTimeout, protocols, retryLimits, url, }: WebSocketConnectionConfig);
+    constructor({ callback, connectionTimeout, protocols, url, }: WebSocketConnectionConfig);
     get connectionTimeout(): number;
     get protocols(): WebSocketProtocol;
-    get requiresLogin(): boolean;
     get isClosed(): boolean;
     get isDisconnected(): boolean;
-    get isConnecting(): boolean;
-    get status(): InternalConnectionStatus;
-    private set status(value);
-    get connectionState(): WebSocketConnectionState<InternalConnectionStatus>;
-    private get hasConnectionAttemptsRemaining();
-    private get confirmedOpen();
+    get connectionPhase(): ConnectionPhase;
+    get connectionStatus(): ConnectionStatus;
+    private set connectionStatus(value);
+    get confirmedOpen(): boolean;
     /**
      * We are 'confirmedOpen' when we see the first message transmitted
      * from the server. This ensures that even if we have one or more
@@ -64,10 +47,8 @@ export declare class WebSocketConnection extends EventEmitter<WebSocketConnectio
      */
     private set confirmedOpen(value);
     get url(): string;
-    connect(clientCall?: boolean): Promise<unknown>;
-    private reconnect;
+    openWebSocket(): Promise<unknown>;
     private receive;
     send: (msg: VuuClientMessage) => void;
     close(reason?: WebSocketConnectionCloseReason): void;
 }
-export {};

package/types/authenticate.d.ts

@@ -8,4 +8,8 @@ export type AuthenticationResponse = {
     token: string;
     user: VuuUser;
 };
+export declare const getVuuAuthToken: (authUrl: string, token: string) => Promise<{
+    authorizations: string[];
+    token: string;
+}>;
 export declare const authenticate: (username: string, password: string, authUrl?: string) => Promise<AuthenticationResponse>;

package/types/index.d.ts

@@ -1,8 +1,11 @@
-export { authenticate, parseVuuUserFromToken } from "./authenticate";
+export { authenticate, getVuuAuthToken, parseVuuUserFromToken, } from "./authenticate";
 export * from "./ConnectionManager";
 export { default as ConnectionManager } from "./ConnectionManager";
 export * from "./constants";
 export * from "./data-source";
+export { LostConnectionHandler, RetryOptions } from "./LostConnectionHandler";
 export * from "./message-utils";
+export { VuuAuthenticator, VuuAuthTokenIssuePolicy } from "./VuuAuthenticator";
+export { VuuAuthProvider, type AuthProvider } from "./VuuAuthProvider";
 export * from "./VuuDataSource";
-export { isConnected, type WebSocketConnectionState, } from "./WebSocketConnection";
+export { isConnected, type ConnectionStatus } from "./WebSocketConnection";