@vuu-ui/vuu-data-remote 3.3.10 → 4.0.0-alpha.1

package/src/LostConnectionHandler.js

@@ -1,89 +0,0 @@
-function _to_primitive(input, hint) {
-    if ("object" !== _type_of(input) || null === input) return input;
-    var prim = input[Symbol.toPrimitive];
-    if (void 0 !== prim) {
-        var res = prim.call(input, hint || "default");
-        if ("object" !== _type_of(res)) return res;
-        throw new TypeError("@@toPrimitive must return a primitive value.");
-    }
-    return ("string" === hint ? String : Number)(input);
-}
-function _to_property_key(arg) {
-    var key = _to_primitive(arg, "string");
-    return "symbol" === _type_of(key) ? key : String(key);
-}
-function _type_of(obj) {
-    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-let _computedKey;
-class RetryOptionsImpl {
-    retryIntervals;
-    ind = 0;
-    constructor(retryIntervals){
-        this.retryIntervals = retryIntervals;
-        console.log("[RetryOptionsImpl] constructor");
-    }
-    next() {
-        this.ind = Math.min(this.retryIntervals.length, this.ind + 1);
-    }
-    get remaining() {
-        return this.retryIntervals.length - this.ind;
-    }
-    get interval() {
-        if (this.ind === this.retryIntervals.length) return -1;
-        return 1000 * this.retryIntervals[this.ind];
-    }
-}
-function RetryOptions(retryIntervals) {
-    if (Array.isArray(retryIntervals)) return new RetryOptionsImpl(retryIntervals);
-    throw Error("[lostConnectionHandler] RetryOptions, invalid retryIntervals");
-}
-const defaultRetryIntervals = [
-    1,
-    2,
-    3,
-    5,
-    10,
-    30,
-    60,
-    120
-];
-_computedKey = _to_property_key(Symbol.asyncIterator);
-class RetryGenerator {
-    vuuAuth;
-    options;
-    constructor(vuuAuth, options){
-        this.vuuAuth = vuuAuth;
-        this.options = options;
-        console.log("[RetryGenerator] constructor");
-    }
-    async *[_computedKey]() {
-        let connected = false;
-        do {
-            await new Promise((resolve)=>setTimeout(resolve, this.options.interval));
-            try {
-                await this.vuuAuth.login();
-                connected = true;
-                yield "connected";
-            } catch (err) {}
-            this.options.next();
-        }while (!connected && -1 !== this.options.interval)
-        if (!connected) yield "connection-failed";
-    }
-}
-class LostConnectionHandler {
-    vuuAuth;
-    retryIntervals;
-    constructor(vuuAuth, retryIntervals = defaultRetryIntervals){
-        this.vuuAuth = vuuAuth;
-        this.retryIntervals = retryIntervals;
-    }
-    async reconnect() {
-        for await (const result of new RetryGenerator(this.vuuAuth, RetryOptions(this.retryIntervals))){
-            console.log(`  ... async iterator result = ${result}`);
-            if ("connected" === result) return result;
-        }
-        return "connection-failed";
-    }
-}
-export { LostConnectionHandler, RetryGenerator, RetryOptions };

package/src/VuuAuthProvider.js

@@ -1,78 +0,0 @@
-import { getCookieValue } from "@vuu-ui/vuu-utils";
-import { parseVuuUserFromToken } from "./authenticate.js";
-class VuuAuthProvider {
-    authEndpoint;
-    constructor(authEndpoint){
-        this.authEndpoint = authEndpoint;
-    }
-    login = async (username, password)=>{
-        const date = new Date();
-        const days = 1;
-        date.setTime(date.getTime() + 24 * days * 3600000);
-        if (username && password) {
-            const { token } = await this.getVuuTokenWithUsernameAndPassword(username, password);
-            document.cookie = `vuu-auth-user=${username};expires=${date.toUTCString()};path=/`;
-            document.cookie = `vuu-auth-password=${password};expires=${date.toUTCString()};path=/`;
-            document.cookie = `vuu-auth-token=${token};expires=${date.toUTCString()};path=/`;
-            return this.redirectToApplication();
-        }
-        {
-            const userName = getCookieValue("vuu-auth-user");
-            const password = getCookieValue("vuu-auth-password");
-            if (!userName || !password) return this.redirectToLoginPage();
-            {
-                const { authorizations, token } = await this.getVuuTokenWithUsernameAndPassword(userName, password);
-                document.cookie = `vuu-auth-token=${token};expires=${date.toUTCString()};path=/`;
-                return {
-                    authorizations,
-                    user: {
-                        userName
-                    },
-                    token
-                };
-            }
-        }
-    };
-    async getVuuTokenWithUsernameAndPassword(username, password) {
-        const response = await fetch(this.authEndpoint, {
-            method: "POST",
-            credentials: "include",
-            headers: {
-                "Content-Type": "application/json",
-                "access-control-allow-origin": location.host
-            },
-            body: JSON.stringify({
-                username,
-                password
-            })
-        });
-        if (response.ok) {
-            const vuuAuthToken = response.headers.get("vuu-auth-token");
-            if ("string" == typeof vuuAuthToken && vuuAuthToken.length > 0) {
-                const { authorizations } = parseVuuUserFromToken(vuuAuthToken);
-                return {
-                    authorizations,
-                    token: vuuAuthToken
-                };
-            }
-            throw Error("Authentication failed auth token not returned by server");
-        }
-        throw Error(`Authentication failed, ${response.status}`);
-    }
-    clear() {
-        document.cookie = "vuu-auth-user= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
-        document.cookie = "vuu-auth-password= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
-        document.cookie = "vuu-auth-token= ; expires = Thu, 01 Jan 1970 00:00:00 GMT";
-    }
-    redirectToLoginPage() {
-        window.location.href = "login.html";
-    }
-    redirectToApplication() {
-        window.location.href = "index.html";
-    }
-    logout() {
-        this.clear();
-        this.redirectToLoginPage();
-    }
-}
-export { VuuAuthProvider };

package/src/VuuAuthenticator.js

@@ -1,36 +0,0 @@
-import ConnectionManager from "./ConnectionManager.js";
-const VuuAuthTokenIssuePolicy = {
-    BearerToken: "bearer-token",
-    UsernamePassword: "username-password"
-};
-class VuuAuthenticator {
-    authProvider;
-    authTokenIssuePolicy;
-    websocketUrl;
-    constructor({ authProvider, authTokenIssuePolicy = VuuAuthTokenIssuePolicy.BearerToken, websocketUrl }){
-        this.authProvider = authProvider;
-        this.authTokenIssuePolicy = authTokenIssuePolicy;
-        this.websocketUrl = websocketUrl;
-    }
-    openWebsocketConnection = async (vuuToken)=>{
-        await ConnectionManager.connect({
-            url: this.websocketUrl,
-            token: vuuToken
-        }, true);
-    };
-    login = async ()=>{
-        const { authorizations, user, token, websocket = true } = await this.authProvider.login();
-        if (token && user) {
-            if (websocket) await this.openWebsocketConnection(token);
-            return [
-                user,
-                authorizations
-            ];
-        }
-        throw Error("[VuuAuthenticator] login failed");
-    };
-    logout = ()=>{
-        this.authProvider.logout();
-    };
-}
-export { VuuAuthTokenIssuePolicy, VuuAuthenticator };

package/src/authenticate.js

@@ -1,50 +0,0 @@
-const defaultAuthUrl = "api/authn";
-const isValidVuuUser = (response)=>"object" == typeof response && null !== response && "name" in response && "authorizations" in response && "string" == typeof response.name && Array.isArray(response.authorizations);
-const parseVuuUserFromToken = (token)=>{
-    const [base64EncodedVuuUser] = token.split(".");
-    const jsonString = atob(base64EncodedVuuUser);
-    const response = JSON.parse(jsonString);
-    if (isValidVuuUser(response)) return response;
-    throw Error("auth token does not containe VuuUser");
-};
-const getVuuAuthToken = async (authUrl, token)=>{
-    const response = await fetch(authUrl, {
-        headers: {
-            Authorization: `Bearer ${token}`
-        }
-    });
-    if (!response.ok) throw Error("Authentication error: Auth token failure");
-    const json = await response.json();
-    const vuuUser = parseVuuUserFromToken(json.token);
-    return {
-        authorizations: vuuUser.authorizations,
-        token: json.token
-    };
-};
-const authenticate = async (username, password, authUrl = defaultAuthUrl)=>fetch(authUrl, {
-        method: "POST",
-        credentials: "include",
-        headers: {
-            "Content-Type": "application/json",
-            "access-control-allow-origin": location.host
-        },
-        body: JSON.stringify({
-            username,
-            password
-        })
-    }).then((response)=>{
-        if (response.ok) {
-            const authToken = response.headers.get("vuu-auth-token");
-            if ("string" == typeof authToken && authToken.length > 0) try {
-                return {
-                    token: authToken,
-                    user: parseVuuUserFromToken(authToken)
-                };
-            } catch (e) {
-                throw Error("Authentication error:  vuu auth token decoding failed.");
-            }
-            throw Error("Authentication failed auth token not returned by server");
-        }
-        throw Error(`Authentication failed ${response.status} ${response.statusText}`);
-    });
-export { authenticate, getVuuAuthToken, parseVuuUserFromToken };