@dative-gpi/foundation-shared-services 0.0.54 → 0.0.55

package/composables/services/useUsers.ts

@@ -1,5 +1,6 @@
-import { UpdateUserDTO, UserDetails, UserDetailsDTO } from "@dative-gpi/foundation-shared-domain/models";
+import { Ref } from "vue";
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
+import { UpdateUserDTO, UserDetails, UserDetailsDTO } from "@dative-gpi/foundation-shared-domain/models";
 
 import { USER_CURRENT_URL } from "../../config/urls";
 
@@ -15,12 +16,15 @@ const UserServiceFactory = new ServiceFactory<UserDetailsDTO, UserDetails>("user
 ));
 
 export const useTrackUser = ComposableFactory.track(UserServiceFactory);
+export const useTrackUserRef = ComposableFactory.trackRef(UserServiceFactory);
 
-export const useCurrentUser = ComposableFactory.custom(UserServiceFactory.getCurrent, () => {
-    const { track } = useTrackUser();
- 
-    return (user) => {
+const trackUser = () => {
+    const { track } = useTrackUserRef();
+
+    return (user: Ref<UserDetails>) => {
         track(user);
     }
-});
-export const useUpdateCurrentUser = ComposableFactory.custom(UserServiceFactory.updateCurrent);
+}
+
+export const useCurrentUser = ComposableFactory.custom(UserServiceFactory.getCurrent, trackUser);
+export const useUpdateCurrentUser = ComposableFactory.custom(UserServiceFactory.updateCurrent, trackUser);

package/composables/useFoundationShared.ts

@@ -9,6 +9,6 @@ export function useFoundationShared() {
   const ready = computed(() => timeZoneReady.value && languageCodeReady.value);
 
   return {
-    ready,
+    ready
   };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dative-gpi/foundation-shared-services",
   "sideEffects": false,
-  "version": "0.0.54",
+  "version": "0.0.55",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -10,11 +10,11 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/bones-ui": "^0.0.70",
-    "@dative-gpi/foundation-shared-domain": "0.0.54",
+    "@dative-gpi/bones-ui": "^0.0.73",
+    "@dative-gpi/foundation-shared-domain": "0.0.55",
     "@microsoft/signalr": "^8.0.0",
     "vue": "^3.2.0",
     "vue-router": "^4.2.5"
   },
-  "gitHead": "391503e595cd9d731fca14b5bb2d3a10b6efee95"
+  "gitHead": "c7ec3fb302319a1f49bb44f60c288eda9dec57d6"
 }

package/tools/hubFactory.ts

@@ -0,0 +1,116 @@
+import { computed, onUnmounted, ref, watch } from "vue";
+import * as signalR from "@microsoft/signalr";
+
+export class HubFactory {
+    static create(
+        url: string | (() => string),
+        configureHooks: (connection: signalR.HubConnection,
+            { isWatched, hasWatchers }: { isWatched: (id: string) => boolean, hasWatchers: () => boolean }) => void,
+        init: (connection: signalR.HubConnection) => Promise<void>) {
+
+        let connection: signalR.HubConnection | null = null;
+        let subscribed = false;
+        let watchManySubscribers = 0;
+        let watcheds = ref<string[]>([]);
+
+        return () => {
+            const connect = async () => {
+                if (!connection) {
+                    connection = new signalR.HubConnectionBuilder()
+                        .withUrl(typeof url == "string" ? url : url())
+                        .configureLogging(signalR.LogLevel.Warning)
+                        .withAutomaticReconnect()
+                        .build();
+
+                    configureHooks(connection, {
+                        isWatched: (id: string) => watcheds.value.includes(id),
+                        hasWatchers: () => watchManySubscribers > 0,
+                    })
+                }
+                if (connection.state !== signalR.HubConnectionState.Connected) {
+                    await connection.start();
+                }
+                if (!subscribed) {
+                    await init(connection);
+                    subscribed = true;
+                }
+            }
+
+            const disconnect = async () => {
+                if (connection) {
+                    await connection.stop();
+                    connection = null;
+                }
+            }
+
+            const hasSubscribers = computed(() => watcheds.value.length > 0 || watchManySubscribers > 0);
+
+            watch(hasSubscribers, async (value) => {
+                if (value) {
+                    await connect();
+                } else {
+                    await disconnect();
+                }
+            }, { immediate: true });
+
+            const subscribeToOne = (alertId: string) => {
+                watcheds.value.push(alertId);
+            }
+
+            const unsubscribeFromOne = (alertId: string) => {
+                const index = watcheds.value.indexOf(alertId);
+                if (index > -1) watcheds.value = watcheds.value.splice(index, 1);
+            }
+
+            const subscribeToMany = () => {
+                watchManySubscribers++;
+            }
+
+            const unsubscribeFromMany = () => {
+                watchManySubscribers--;
+            }
+
+            return {
+                subscribeToOne,
+                unsubscribeFromOne,
+                subscribeToMany,
+                unsubscribeFromMany
+            }
+        }
+    }
+
+    static createWatcher(factory: ReturnType<typeof this.create>) {
+        return () => {
+            const { subscribeToOne, unsubscribeFromOne, subscribeToMany, unsubscribeFromMany } = factory();
+
+            const manySubscriptions = ref(false);
+            const oneSubscriptions = ref<string[]>([]);
+
+            onUnmounted(() => {
+                if (manySubscriptions.value) {
+                    unsubscribeFromMany();
+                }
+                for (let subscription of oneSubscriptions.value) {
+                    unsubscribeFromOne(subscription);
+                }
+            })
+
+            const watchOne = (id: string) => {
+                subscribeToOne(id);
+                oneSubscriptions.value.push(id);
+            }
+
+            const watchMany = () => {
+                if (manySubscriptions.value === false) {
+                    subscribeToMany();
+                    manySubscriptions.value = true;
+                }
+            }
+
+            return {
+                watchOne,
+                watchMany
+            }
+        }
+    }
+} 

package/tools/index.ts

@@ -0,0 +1 @@
+export * from "./hubFactory";