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

package/composables/services/useApplications.ts

@@ -3,9 +3,8 @@ import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
 import { APPLICATION_CURRENT_URL } from "../../config/urls";
 
-const ApplicationServiceFactory = new ServiceFactory<ApplicationDetailsDTO, ApplicationDetails>("application", ApplicationDetails).create(factory => factory.build(
-    factory.addCustom("getCurrent", (axios) => axios.get(APPLICATION_CURRENT_URL())),
-    factory.addNotify()
-));
+const ApplicationServiceFactory = {
+    ...ServiceFactory.addCustom("getCurrent", (axios) => axios.get(APPLICATION_CURRENT_URL()), (dto: ApplicationDetailsDTO) => new ApplicationDetails(dto))
+};
 
-export const useCurrentApplication = ComposableFactory.custom(ApplicationServiceFactory, ApplicationServiceFactory.getCurrent);
+export const useCurrentApplication = ComposableFactory.custom(ApplicationServiceFactory.getCurrent);

package/composables/services/useImages.ts

@@ -1,11 +1,10 @@
 import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
-import { BlurHash } from "@dative-gpi/foundation-shared-domain/models";
+import { BlurHash, BlurHashDTO } from "@dative-gpi/foundation-shared-domain/models";
 
 import { IMAGE_BLURHASH_URL } from "../../config/urls";
 
-const ImageServiceFactory = new ServiceFactory("image", BlurHash).create(factory => factory.build(
-    factory.addCustom("getBlurHash", (axios, imageId: string) => axios.get(IMAGE_BLURHASH_URL(imageId))),
-    factory.addNotify()
-));
+const ImageServiceFactory = {
+    ...ServiceFactory.addCustom("getBlurHash", (axios, imageId: string) => axios.get(IMAGE_BLURHASH_URL(imageId)), (dto: BlurHashDTO) => new BlurHash(dto))
+};
 
-export const useImageBlurHash = ComposableFactory.custom(ImageServiceFactory, ImageServiceFactory.getBlurHash);
+export const useImageBlurHash = ComposableFactory.custom(ImageServiceFactory.getBlurHash);

package/composables/services/useTranslations.ts

@@ -1,41 +1,10 @@
-import { ref } from "vue";
-
-import { TranslationInfos, TranslationInfosDTO, TranslationDetails, TranslationDetailsDTO } from "@dative-gpi/foundation-shared-domain/models";
-import { ServiceFactory } from "@dative-gpi/bones-ui";
+import { TranslationInfos, TranslationInfosDTO } from "@dative-gpi/foundation-shared-domain/models";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui";
 
 import { TRANSLATIONS_LANGUAGE_URL } from "../../config/urls";
 
-const TranslationServiceFactory = new ServiceFactory<TranslationDetailsDTO, TranslationDetails>("translation", TranslationDetails).create(factory => factory.build(
-    factory.addNotify(() => ({
-        getMany: async (languageCode: string): Promise<TranslationInfos[]> => {
-            const response = await ServiceFactory.http.get(TRANSLATIONS_LANGUAGE_URL(languageCode));
-            const result = response.data.map((dto: TranslationInfosDTO) => new TranslationInfos(dto));
-
-            return result;
-        }
-    }))
-));
-
-export const useTranslations = () => {
-    const service = TranslationServiceFactory();
-
-    const fetching = ref(false);
-    const entities = ref<TranslationInfos[]>([]);
-
-    const getMany = async (languageCode: string) => {
-        fetching.value = true;
-        try {
-            entities.value = await service.getMany(languageCode);
-        }
-        finally {
-            fetching.value = false;
-        }
-        return entities;
-    }
+const TranslationServiceFactory = {
+    ...ServiceFactory.addCustom("getMany", (axios, languageCode: string) => axios.get(TRANSLATIONS_LANGUAGE_URL(languageCode)), (dtos: TranslationInfosDTO[]) => dtos.map(dto => new TranslationInfos(dto)))
+};
 
-    return {
-        fetching,
-        getMany,
-        entities
-    }
-}
+export const useTranslations = ComposableFactory.custom(TranslationServiceFactory.getMany);

package/composables/services/useUsers.ts

@@ -1,13 +1,30 @@
-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";
 
 const UserServiceFactory = new ServiceFactory<UserDetailsDTO, UserDetails>("user", UserDetails).create(factory => factory.build(
-    factory.addCustom("getCurrent", (axios) => axios.get(USER_CURRENT_URL())),
-    factory.addCustom("updateCurrent", (axios, payload: UpdateUserDTO) => axios.post(USER_CURRENT_URL(), payload)),
-    factory.addNotify()
+    ServiceFactory.addCustom("getCurrent", (axios) => axios.get(USER_CURRENT_URL()), (dto: UserDetailsDTO) => new UserDetails(dto)),
+    factory.addNotify(notify => ({
+        ...ServiceFactory.addCustom("updateCurrent", (axios, payload: UpdateUserDTO) => axios.post(USER_CURRENT_URL(), payload), (dto: UserDetailsDTO) => {
+            const result = new UserDetails(dto);
+            notify.notify("update", result);
+            return result;
+        })
+    }))
 ));
 
-export const useCurrentUser = ComposableFactory.custom(UserServiceFactory, UserServiceFactory.getCurrent);
-export const useUpdateCurrentUser = ComposableFactory.custom(UserServiceFactory, UserServiceFactory.updateCurrent);
+export const useTrackUser = ComposableFactory.track(UserServiceFactory);
+export const useTrackUserRef = ComposableFactory.trackRef(UserServiceFactory);
+
+const trackUser = () => {
+    const { track } = useTrackUserRef();
+
+    return (user: Ref<UserDetails>) => {
+        track(user);
+    }
+}
+
+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.53",
+  "version": "0.0.55",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -10,11 +10,11 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/bones-ui": "^0.0.67",
-    "@dative-gpi/foundation-shared-domain": "0.0.53",
+    "@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": "4ecd4c47590cb49ab9f480e12202cde9af5396e1"
+  "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";