libshv-js 3.17.0 → 3.20.0

package/dist/rpcvalue.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isShvMap = exports.isMetaMap = exports.isIMap = exports.makeMetaMap = exports.makeIMap = exports.makeMap = exports.withOffset = exports.UInt = exports.RpcValueWithMetaData = exports.Double = exports.Decimal = exports.shvMapType = exports.typeName = void 0;
+class UInt {
+    value;
+    constructor(u) {
+        if (u instanceof UInt) {
+            this.value = u.value;
+            return;
+        }
+        if (u < 0 || !Number.isInteger(u)) {
+            throw new Error(`Invalid value '${u}' for UInt must a positive integral number`);
+        }
+        this.value = u;
+    }
+    [Symbol.toPrimitive]() {
+        return this.value;
+    }
+    toString() {
+        return `${this.value.toString()}`;
+    }
+}
+exports.UInt = UInt;
+class Double {
+    value;
+    constructor(u) {
+        this.value = u;
+    }
+}
+exports.Double = Double;
+class Decimal {
+    mantisa;
+    exponent;
+    constructor(mantisa, exponent) {
+        if (!Number.isInteger(exponent)) {
+            throw new TypeError(`Decimal: exponent must be integral (${exponent})`);
+        }
+        this.mantisa = mantisa;
+        this.exponent = exponent;
+    }
+}
+exports.Decimal = Decimal;
+const withOffset = (date, utcOffset) => {
+    const clonedDate = new Date(date);
+    clonedDate.utc_offset = utcOffset;
+    return clonedDate;
+};
+exports.withOffset = withOffset;
+const shvMapType = Symbol('shvMapType');
+exports.shvMapType = shvMapType;
+const isShvMap = (x) => typeof x === 'object' && x[shvMapType] === 'map';
+exports.isShvMap = isShvMap;
+const isIMap = (x) => typeof x === 'object' && x[shvMapType] === 'imap';
+exports.isIMap = isIMap;
+const isMetaMap = (x) => typeof x === 'object' && x[shvMapType] === 'metamap';
+exports.isMetaMap = isMetaMap;
+const typeName = (x) => {
+    switch (true) {
+        case x === undefined: return 'Null';
+        case typeof x === 'boolean': return 'Bool';
+        case typeof x === 'string': return 'String';
+        case x instanceof ArrayBuffer: return 'Blob';
+        case x instanceof UInt: return 'UInt';
+        case typeof x === 'number': return 'Int';
+        case x instanceof Double: return 'Double';
+        case x instanceof Decimal: return 'Decimal';
+        case Array.isArray(x): return 'List';
+        case x instanceof Date: return 'Date';
+        case isShvMap(x): return 'ShvMap';
+        case isIMap(x): return 'IMap';
+        case isMetaMap(x): return 'MetaMap';
+        default: return '<unknown type>';
+    }
+};
+exports.typeName = typeName;
+const makeMetaMap = (x = {}) => ({
+    ...x,
+    [shvMapType]: 'metamap',
+});
+exports.makeMetaMap = makeMetaMap;
+const makeIMap = (x = {}) => ({
+    ...x,
+    [shvMapType]: 'imap',
+});
+exports.makeIMap = makeIMap;
+const makeMap = (x = {}) => ({
+    ...x,
+    [shvMapType]: 'map',
+});
+exports.makeMap = makeMap;
+class RpcValueWithMetaData {
+    meta;
+    value;
+    constructor(meta, value) {
+        this.meta = meta;
+        this.value = value;
+        /* nothing */
+    }
+}
+exports.RpcValueWithMetaData = RpcValueWithMetaData;

package/dist/vue-shv.d.ts

@@ -0,0 +1,91 @@
+import { ComputedRef, Ref } from 'vue';
+import { WsClient, WsClientOptionsLogin } from './ws-client';
+import PKCE from 'js-pkce';
+import * as z from './zod';
+import { type shvMapType } from './rpcvalue';
+import { RpcValue } from './rpcvalue';
+type GlobalResourceOptions<ResourceType> = {
+    shvPath: string;
+    method: string;
+    validator: z.ZodType<ResourceType>;
+    signalName: string;
+    signalHandler: (param: RpcValue, resource: Ref<ResourceType | undefined>, reinit: () => void) => void;
+};
+type VueShvOptions = {
+    wsUri: string;
+    onRequest: WsClientOptionsLogin['onRequest'];
+    azureCodeRedirect?: string;
+};
+type ShvLocalStorage = {
+    azureAccessToken?: string;
+    azureRedirectTo?: string;
+};
+type ShvSessionStorage = {
+    shvLoginUser?: string;
+    shvLoginPassword?: string;
+    azureWorkflow?: z.infer<typeof OAuth2AzureWorkflowZod>;
+};
+declare const OAuth2AzureWorkflowZod: z.ZodCustom<{
+    type: "oauth2-azure";
+    authorizeUrl: string;
+    tokenUrl: string;
+    clientId: string;
+    scopes: string | string[];
+} & {
+    [shvMapType]: "map";
+}, {
+    type: "oauth2-azure";
+    authorizeUrl: string;
+    tokenUrl: string;
+    clientId: string;
+    scopes: string | string[];
+} & {
+    [shvMapType]: "map";
+}>;
+export declare enum LoginFailureReason {
+    NoCredentials = 0,
+    AzureTimedOut = 1,
+    AzureUnsupported = 2,
+    CouldntLogin = 3,
+    LoggedOut = 4
+}
+type LoginFailure = {
+    reason: LoginFailureReason;
+    message?: string;
+};
+declare const makePkce: (oauthOptions: {
+    azureCodeRedirect: string;
+    clientId: string;
+    authorizeUrl: string;
+    tokenUrl: string;
+    scopes: string | string[];
+}) => PKCE;
+export { makePkce as azure };
+export declare function useShv(options: VueShvOptions): {
+    azureAuth: (redirectTo?: string) => void;
+    azureHandlerError: Ref<string, string>;
+    connected: Ref<"connected" | "connecting" | "disconnected", "connected" | "connecting" | "disconnected">;
+    displayEmail: Ref<string, string>;
+    displayFullName: Ref<string, string>;
+    displayName: Ref<string, string>;
+    displayPhoto: Ref<string | undefined, string | undefined>;
+    displayShortName: Ref<string, string>;
+    getConnection: () => Promise<WsClient>;
+    handleAzureCode: () => Promise<string | void>;
+    logContents: Ref<string, string>;
+    loginFailure: Ref<LoginFailure | undefined, LoginFailure | undefined>;
+    makeGlobalResource: {
+        <ResourceType>(options: GlobalResourceOptions<ResourceType>): () => Ref<ResourceType | undefined>;
+        <ResourceType>(options: GlobalResourceOptions<ResourceType> & {
+            default: ResourceType;
+        }): () => ComputedRef<ResourceType>;
+    };
+    makeRpcCall: <ResultType>(shvPath: string, method: string, validator: z.ZodType<ResultType>) => () => Promise<Error | ResultType>;
+    makeRpcCallParam: <ResultType, ParamType extends RpcValue>(shvPath: string, method: string, _paramType: z.ZodType<ParamType>, validator: z.ZodType<ResultType>) => (param: ParamType) => Promise<Error | ResultType>;
+    rpcCall: (shvPath: string, method: string, params?: RpcValue) => Promise<Error | RpcValue>;
+    setShvCredentials: (userName: string, password: string) => void;
+    shvLocalStorage: import("@vueuse/shared").RemovableRef<ShvLocalStorage>;
+    shvLogout: () => void;
+    shvSessionStorage: import("@vueuse/shared").RemovableRef<ShvSessionStorage>;
+};
+export declare const fullReloadHandler: (_param: RpcValue, _resource: unknown, reinit: () => void) => void;

package/dist/vue-shv.js

@@ -0,0 +1,424 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullReloadHandler = exports.azure = exports.LoginFailureReason = void 0;
+exports.useShv = useShv;
+const vue_1 = require("vue");
+const ws_client_1 = require("./ws-client");
+const core_1 = require("@vueuse/core");
+const js_pkce_1 = __importDefault(require("js-pkce"));
+const z = __importStar(require("./zod"));
+const OAuth2AzureWorkflowZod = z.map({
+    type: z.literal('oauth2-azure'),
+    authorizeUrl: z.string(),
+    tokenUrl: z.string(),
+    clientId: z.string(),
+    scopes: z.string().or(z.array(z.string())),
+});
+var LoginFailureReason;
+(function (LoginFailureReason) {
+    LoginFailureReason[LoginFailureReason["NoCredentials"] = 0] = "NoCredentials";
+    LoginFailureReason[LoginFailureReason["AzureTimedOut"] = 1] = "AzureTimedOut";
+    LoginFailureReason[LoginFailureReason["AzureUnsupported"] = 2] = "AzureUnsupported";
+    LoginFailureReason[LoginFailureReason["CouldntLogin"] = 3] = "CouldntLogin";
+    LoginFailureReason[LoginFailureReason["LoggedOut"] = 4] = "LoggedOut";
+})(LoginFailureReason || (exports.LoginFailureReason = LoginFailureReason = {}));
+const makePkce = (oauthOptions) => {
+    const pkce = new js_pkce_1.default({
+        client_id: oauthOptions.clientId,
+        redirect_uri: (() => {
+            const url = new URL(globalThis.location.href);
+            url.pathname = oauthOptions.azureCodeRedirect;
+            url.search = '';
+            return url.toString();
+        })(),
+        authorization_endpoint: oauthOptions.authorizeUrl,
+        token_endpoint: oauthOptions.tokenUrl,
+        requested_scopes: Array.isArray(oauthOptions.scopes) ? oauthOptions.scopes.join(' ') : oauthOptions.scopes,
+    });
+    return pkce;
+};
+exports.azure = makePkce;
+function useShv(options) {
+    const shvLocalStorage = (0, core_1.useLocalStorage)('vue-shv', {});
+    const shvSessionStorage = (0, core_1.useSessionStorage)('vue-shv', {});
+    const displayName = (0, vue_1.ref)('Loading...');
+    const displayShortName = (0, vue_1.ref)('');
+    const displayFullName = (0, vue_1.ref)('');
+    const displayEmail = (0, vue_1.ref)('');
+    const displayPhoto = (0, vue_1.ref)();
+    const state = {
+        ws: undefined,
+        reconnectService: undefined,
+    };
+    const waitingForSocket = [];
+    const resetAzureToken = () => {
+        shvLocalStorage.value.azureAccessToken = undefined;
+    };
+    const azureAvailable = async () => {
+        const accessToken = shvLocalStorage.value.azureAccessToken;
+        if (accessToken === undefined) {
+            return LoginFailureReason.NoCredentials;
+        }
+        const resp = await fetch('https://graph.microsoft.com/v1.0/me', {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        const json = await resp.json();
+        if (typeof json === 'object' && json !== null) {
+            if ('displayName' in json && typeof json.displayName === 'string') {
+                displayName.value = json.displayName;
+            }
+            if ('givenName' in json && typeof json.givenName === 'string'
+                && 'surname' in json && typeof json.surname === 'string') {
+                const firstName = json.givenName;
+                const lastname = json.surname;
+                displayShortName.value = firstName.charAt(0) + lastname.charAt(0);
+                displayFullName.value = firstName + ' ' + lastname;
+            }
+            if ('mail' in json && typeof json.mail === 'string') {
+                displayEmail.value = json.mail;
+            }
+        }
+        const photo = await fetch('https://graph.microsoft.com/v1.0/me/photos/48x48/$value', {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        if (photo.ok) {
+            displayPhoto.value = URL.createObjectURL(await photo.blob());
+        }
+        if (!resp.ok) {
+            resetAzureToken();
+        }
+        return resp.ok ? 'azureAvailable' : LoginFailureReason.AzureTimedOut;
+    };
+    const debug = (...args) => {
+        logContents.value = logContents.value + args.join(' ') + '\n';
+        console.debug(...args);
+    };
+    const azureAuth = (redirectTo) => {
+        if (options.azureCodeRedirect === undefined) {
+            throw new Error('Azure redirect URL not set');
+        }
+        const { azureCodeRedirect } = options;
+        shvLocalStorage.value.azureRedirectTo = redirectTo ?? globalThis.location.pathname;
+        const noBrokerSupport = () => {
+            loginFailure.value = {
+                reason: LoginFailureReason.AzureUnsupported,
+                message: 'Broker does not support Azure',
+            };
+        };
+        state.ws = new ws_client_1.WsClient({
+            logDebug: debug,
+            wsUri: options.wsUri,
+            onWorkflows(workflows) {
+                if (!Array.isArray(workflows)) {
+                    noBrokerSupport();
+                    return;
+                }
+                for (const workflow of workflows) {
+                    const parsedWorkflow = OAuth2AzureWorkflowZod.safeParse(workflow);
+                    if (!parsedWorkflow.success) {
+                        continue;
+                    }
+                    shvSessionStorage.value.azureWorkflow = parsedWorkflow.data;
+                    globalThis.location.replace(makePkce({ ...parsedWorkflow.data, azureCodeRedirect }).authorizeUrl());
+                }
+            },
+            onWorkflowsFailed() {
+                noBrokerSupport();
+            },
+        });
+    };
+    const setShvCredentials = (userName, password) => {
+        shvLogout();
+        shvSessionStorage.value.shvLoginUser = userName;
+        shvSessionStorage.value.shvLoginPassword = password;
+    };
+    const rpcCall = async (shvPath, method, params) => {
+        const shv = await getConnection();
+        return shv.callRpcMethod(shvPath, method, params);
+    };
+    const makeRpcCall = (shvPath, method, validator) => async () => {
+        const resultOrError = await rpcCall(shvPath, method);
+        if (resultOrError instanceof Error) {
+            return resultOrError;
+        }
+        const parsed = validator.safeParse(resultOrError);
+        if (!parsed.success) {
+            return new Error(parsed.error.message);
+        }
+        return parsed.data;
+    };
+    const makeRpcCallParam = (shvPath, method, _paramType, validator) => async (param) => {
+        const resultOrError = await rpcCall(shvPath, method, param);
+        if (resultOrError instanceof Error) {
+            return resultOrError;
+        }
+        const parsed = validator.safeParse(resultOrError);
+        if (!parsed.success) {
+            return new Error(parsed.error.message);
+        }
+        return parsed.data;
+    };
+    const connected = (0, vue_1.ref)('disconnected');
+    const logContents = (0, vue_1.ref)('');
+    const shvLogout = () => {
+        resetAzureToken();
+        shvSessionStorage.value.shvLoginUser = undefined;
+        shvSessionStorage.value.shvLoginPassword = undefined;
+        for (const waiter of waitingForSocket) {
+            waiter.reject();
+        }
+        connected.value = 'disconnected';
+        waitingForSocket.length = 0;
+        state.ws?.close();
+        displayName.value = 'Logged out';
+        displayPhoto.value = undefined;
+        state.ws = undefined;
+    };
+    const loginFailure = (0, vue_1.ref)();
+    const getConnection = async () => {
+        if (connected.value === 'connected') {
+            return state.ws;
+        }
+        return new Promise((resolve, reject) => {
+            waitingForSocket.push({ resolve, reject });
+            if (connected.value === 'connecting') {
+                // We should try to connect only once at the same time.
+                return;
+            }
+            connected.value = 'connecting';
+            const doConnect = (user, password, loginType) => {
+                console.log('Connecting to', options.wsUri);
+                const makeLoginOptions = () => {
+                    switch (loginType) {
+                        case 'PLAIN':
+                            return {
+                                type: loginType,
+                                user,
+                                password,
+                            };
+                        case 'TOKEN':
+                            return {
+                                type: loginType,
+                                token: `oauth2-azure:${password}`,
+                            };
+                    }
+                };
+                state.ws = new ws_client_1.WsClient({
+                    login: makeLoginOptions(),
+                    wsUri: options.wsUri,
+                    timeout: 120_000,
+                    logDebug: debug,
+                    onConnected() {
+                        for (const waiter of waitingForSocket) {
+                            waiter.resolve(state.ws);
+                        }
+                        waitingForSocket.length = 0;
+                        console.log('Connected to', options.wsUri);
+                        connected.value = 'connected';
+                    },
+                    onConnectionFailure(error) {
+                        console.error(`Failed to connect to: ${options.wsUri}`, error);
+                        shvLogout();
+                        loginFailure.value = {
+                            reason: LoginFailureReason.CouldntLogin,
+                            message: error.message,
+                        };
+                    },
+                    onDisconnected() {
+                        connected.value = 'disconnected';
+                        const RECONNECT_INTERVAL = 3000;
+                        if (shvLocalStorage.value.azureAccessToken !== undefined) {
+                            console.log('Disconnected from', options.wsUri, 'reconnecting in', RECONNECT_INTERVAL, 'ms');
+                            state.reconnectService = globalThis.setTimeout(async () => {
+                                await getConnection();
+                            }, RECONNECT_INTERVAL);
+                        }
+                    },
+                    onRequest: options.onRequest,
+                });
+            };
+            const shvUser = shvSessionStorage.value.shvLoginUser;
+            const shvPassword = shvSessionStorage.value.shvLoginPassword;
+            if (shvUser !== undefined && shvPassword !== undefined) {
+                displayName.value = shvUser;
+                displayShortName.value = shvUser[0];
+                displayFullName.value = shvUser;
+                doConnect(shvUser, shvPassword, 'PLAIN');
+                return;
+            }
+            azureAvailable().then(isAzureAvailable => {
+                switch (isAzureAvailable) {
+                    case LoginFailureReason.NoCredentials:
+                    case LoginFailureReason.AzureTimedOut:
+                        shvLogout();
+                        loginFailure.value = {
+                            reason: isAzureAvailable,
+                        };
+                        return;
+                    case 'azureAvailable':
+                        break;
+                }
+                const accessToken = shvLocalStorage.value.azureAccessToken;
+                if (accessToken !== undefined) {
+                    doConnect('', accessToken, 'TOKEN');
+                }
+            }).catch((error) => {
+                console.error('Failed to fetch verify azure info, redirecting to the login page in 3 seconds', error);
+                setTimeout(() => {
+                    loginFailure.value = {
+                        reason: LoginFailureReason.CouldntLogin,
+                        message: 'Failed to fetch verify azure info',
+                    };
+                }, 3000);
+            });
+        });
+    };
+    function makeGlobalResource(options) {
+        const resource = (0, vue_1.ref)();
+        const resIdentifier = `${options.shvPath}:${options.method}`;
+        const resourceCall = makeRpcCall(options.shvPath, options.method, options.validator);
+        const refreshValue = async () => {
+            const newResource = await resourceCall();
+            if (newResource instanceof Error) {
+                return;
+            }
+            resource.value = newResource;
+        };
+        const initialize = async () => {
+            try {
+                await refreshValue();
+                const connection = await getConnection();
+                connection.subscribe(`Global-${resIdentifier}:`, options.shvPath, options.signalName, (_path, _method, param) => {
+                    options.signalHandler(param, resource, async () => refreshValue().catch((error) => {
+                        console.error(`Failed to initialize ${resIdentifier}`, error);
+                    }));
+                });
+            }
+            catch (error) {
+                console.error(`Failed to initialize ${resIdentifier}`, error);
+            }
+        };
+        let initialized = false;
+        return () => {
+            if (!initialized) {
+                initialized = true;
+                (0, vue_1.watchEffect)(() => {
+                    if (connected.value !== 'connected') {
+                        return;
+                    }
+                    initialize().catch((error) => {
+                        console.error(`Failed to initialize ${resIdentifier}`, error);
+                    });
+                });
+            }
+            if ('default' in options) {
+                const defaultValue = options.default;
+                const withDefault = (0, vue_1.computed)(() => {
+                    if (resource.value === undefined) {
+                        return defaultValue;
+                    }
+                    return resource.value;
+                });
+                return withDefault;
+            }
+            return resource;
+        };
+    }
+    const azureHandlerError = (0, vue_1.ref)('');
+    const handleAzureCode = async () => {
+        if (shvSessionStorage.value.azureWorkflow === undefined) {
+            azureHandlerError.value = 'Azure error: no active login procedure';
+            return;
+        }
+        if (options.azureCodeRedirect === undefined) {
+            throw new Error('Azure redirect URL not set');
+        }
+        const { azureCodeRedirect } = options;
+        return makePkce({ ...shvSessionStorage.value.azureWorkflow, azureCodeRedirect }).exchangeForAccessToken(globalThis.location.href).then(resp => {
+            shvSessionStorage.value.azureWorkflow = undefined;
+            const token = resp.access_token;
+            if (token === undefined) {
+                azureHandlerError.value = 'Couldn\'t authenticate to Azure: unable to exchange access token';
+                return;
+            }
+            // Store the token and remove the code from the query params.
+            shvLogout();
+            shvLocalStorage.value.azureAccessToken = token;
+            const redirectTo = shvLocalStorage.value.azureRedirectTo;
+            if (redirectTo === undefined) {
+                azureHandlerError.value = 'Couldn\'t authenticate to Azure: no redirect URL';
+                return;
+            }
+            shvLocalStorage.value.azureRedirectTo = undefined;
+            return redirectTo;
+        }).catch((error) => {
+            azureHandlerError.value = `Couldn't authenticate to Azure: ${JSON.stringify(error)}`;
+        });
+    };
+    return {
+        azureAuth,
+        azureHandlerError,
+        connected,
+        displayEmail,
+        displayFullName,
+        displayName,
+        displayPhoto,
+        displayShortName,
+        getConnection,
+        handleAzureCode,
+        logContents,
+        loginFailure,
+        makeGlobalResource,
+        makeRpcCall,
+        makeRpcCallParam,
+        rpcCall,
+        setShvCredentials,
+        shvLocalStorage,
+        shvLogout,
+        shvSessionStorage,
+    };
+}
+const fullReloadHandler = (_param, _resource, reinit) => {
+    reinit();
+};
+exports.fullReloadHandler = fullReloadHandler;