@thzero/library_client_vue3_store_pinia 0.16.20 → 0.16.22

package/openSource.js

@@ -0,0 +1,53 @@
+export default () => {
+    return [
+        {
+            category: 'client',
+            name: '@thzero/library_client',
+            url: 'https://github.com/thzero/library_client',
+            licenseName: 'MIT',
+            licenseUrl: 'https://github.com/thzero/library_client/blob/master/license.md'
+        },
+        {
+            category: 'client',
+            name: '@thzero/library_client_vue3',
+            url: 'https://github.com/thzero/library_client_vue3',
+            licenseName: 'MIT',
+            licenseUrl: 'https://github.com/thzero/library_client_vue3/blob/master/license.md'
+        },
+        {
+            category: 'client',
+            name: '@thzero/library_client_vue3_store_pinia',
+            url: 'https://github.com/thzero/library_client_vue3_store_pinia',
+            licenseName: 'MIT',
+            licenseUrl: 'https://github.com/thzero/library_client_vue3_store_pinia/blob/master/license.md'
+        },
+        {
+            category: 'client',
+            name: '@thzero/library_common',
+            url: 'https://github.com/thzero/library_common',
+            licenseName: 'MIT',
+            licenseUrl: 'https://github.com/thzero/library_common/blob/master/license.md'
+        },
+        {
+            category: 'client',
+            name: 'pinia',
+            url: 'https://github.com/vuejs/pinia',
+            licenseName: 'MIT',
+            licenseUrl: 'https://github.com/vuejs/pinia/blob/v2/LICENSE'
+        },
+        {
+            category: 'client',
+            name: 'pinia-plugin-persistedstate-2',
+            url: 'https://github.com/iendeavor/pinia-plugin-persistedstate-2',
+            licenseName: 'MIT',
+            licenseUrl: 'https://github.com/iendeavor/pinia-plugin-persistedstate-2/blob/main/LICENSE'
+        },
+        {
+            category: 'client',
+            name: 'vue',
+            url: 'https://github.com/vuejs/vue',
+            licenseName: 'MIT',
+            licenseUrl: 'https://github.com/vuejs/vue/blob/dev/LICENSE'
+        }
+    ];
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@thzero/library_client_vue3_store_pinia",
-  "version": "0.16.20",
+  "version": "0.16.22",
   "version_major": 0,
   "version_minor": 16,
-  "version_patch": 20,
-  "version_date": "12/19/2022",
+  "version_patch": 22,
+  "version_date": "12/20/2022",
   "description": "An opinionated library for vue3 with pinia store for the library_client_vue3 using the https://prazdevs.github.io/pinia-plugin-persistedstate library.",
   "author": "thZero",
   "license": "MIT",

package/service/store/index.js

@@ -8,7 +8,7 @@ class PiniaStoreService extends Service {
 	}
 
 	get getters() {
-		return GlobalUtility.$store;
+		return GlobalUtility.$store.getters;
 	}
 
 	get state() {

package/store/index.js

@@ -6,6 +6,8 @@ import LibraryConstants from '@thzero/library_client/constants';
 
 import GlobalUtility from '@thzero/library_client/utility/global';
 
+import Response from '@thzero/library_common/response';
+
 import NotImplementedError from '@thzero/library_common/errors/notImplemented';
 
 // import adminNews from './admin/news/pinia';
@@ -25,11 +27,24 @@ class BaseStore {
 
 	setup() {
 		const logger = GlobalUtility.$injector.getService(LibraryConstants.InjectorKeys.SERVICE_LOGGER);
+
+		const initialStoreConfig = this._initStoreConfigBase();
+		const appStoreConfig = this._initStoreConfig();
+		initialStoreConfig.actions = Object.assign(initialStoreConfig.actions, appStoreConfig.actions);
+		initialStoreConfig.dispatcher = Object.assign(initialStoreConfig.dispatcher, appStoreConfig.dispatcher);
+		initialStoreConfig.getters = Object.assign(initialStoreConfig.getters, appStoreConfig.getters);
+
+		const initialState = initialStoreConfig.state();
+		const appState = appStoreConfig.state();
+		const state = Object.assign(initialState, appState);
+		initialStoreConfig.state = () => state;
+
 		return {
 			func: {
 				install(app, options) {
 					const storeConfig = options.storeConfig;
 					
+					options.actionGetters = storeConfig.getters;
 					options.actionDispatcher = storeConfig.dispatcher;
 					if (!options.actionDispatcher) 
 						options.actionDispatcher = {};
@@ -43,14 +58,16 @@ class BaseStore {
 
 					// options.addModule('adminNews', adminNews, options.actionDispatcher, options.pluginPersistType(), options.pluginPersistConfig, options.pinia, logger);
 					// options.addModule('adminUsers', adminUsers, options.actionDispatcher, options.pluginPersistType(), options.pluginPersistConfig, options.pinia, logger);
-					options.addModule('news', news, options.actionDispatcher, options.pluginPersistType(), options.pluginPersistSetup, options.pluginPersistConfig, options.pluginPersistSetupOverride, options.pinia, logger);
-					options.addModule('user', user, options.actionDispatcher, options.pluginPersistType(), options.pluginPersistSetup, options.pluginPersistConfig, options.pluginPersistSetupOverride, options.pinia, logger);
+					options.addModule('news', news, options.actionDispatcher, options.actionGetters, options.pluginPersistType(), options.pluginPersistSetup, options.pluginPersistConfig, options.pluginPersistSetupOverride, options.pinia, logger);
+					options.addModule('user', user, options.actionDispatcher, options.actionGetters, options.pluginPersistType(), options.pluginPersistSetup, options.pluginPersistConfig, options.pluginPersistSetupOverride, options.pinia, logger);
 					options.initModules();
 					GlobalUtility.$store.dispatcher = options.actionDispatcher;
+					GlobalUtility.$store.getters = options.actionGetters;
 				}
 			},
 			options: {
 				actionDispatcher: this.actionDispatcher,
+				actionGetters: this.actionGetters,
 				addModule: this._addModule,
 				initModules: this._initModules,
 				logger: logger,
@@ -59,25 +76,23 @@ class BaseStore {
 				pluginPersistSetupOverride: this._initPluginPersistConfigSetupOverride,
 				pluginPersistSetup: this._initPluginPersistConfigSetup,
 				pluginPersistType: this._initPluginPersistType,
-				storeConfig: this._init()
+				storeConfig: initialStoreConfig
 			}
 		};
 	}
 
-	_addModule(key, storeConfig, actionDispatcher, pluginPersistType, pluginPersistSetup, pluginPersistConfig, pluginPersistSetupOverride, pinia, logger) {
+	_addModule(key, storeConfig, actionDispatcher, actionGetters, pluginPersistType, pluginPersistSetup, pluginPersistConfig, pluginPersistSetupOverride, pinia, logger) {
 		if (pluginPersistType && pluginPersistSetup && pluginPersistConfig && pluginPersistConfig[key])
 			pluginPersistSetup(pluginPersistType, storeConfig, pluginPersistConfig['root'], pluginPersistSetupOverride);
 		actionDispatcher[key] = storeConfig.dispatcher;
 		delete storeConfig.dispatcher;
+		actionGetters[key] = storeConfig.getters;
+		delete storeConfig.getters;
 		const storeFunc = defineStore(key, storeConfig);
 		GlobalUtility.$store[key] = storeFunc(pinia);
 		GlobalUtility.$store[key].$logger = logger;
 	}
 
-	_init() {
-		throw new NotImplementedError();
-	}
-
 	_initModules() {
 		throw new NotImplementedError();
 	}
@@ -137,6 +152,104 @@ class BaseStore {
 	_initPluginPersistConfigSetupOverride(storeConfig, persistConfig) {
 	}
 
+	_initStoreConfig() {
+		throw new NotImplementedError();
+	}
+
+	_initStoreConfigBase() {
+		return {
+			state: () => ({
+				checksumLastUpdate: [],
+				openSource: [],
+				plans: [],
+				version: null
+			}),
+			actions: {
+				async requestOpenSource(correlationId) {
+					const openSourceCheck = GlobalUtility.$store.openSource;
+					if (openSourceCheck && Array.isArray(openSourceCheck) && openSourceCheck.length > 0)
+						return Response.success(openSourceCheck);
+
+					const service = GlobalUtility.$injector.getService(LibraryConstants.InjectorKeys.SERVICE_UTILITY);
+					const response = await service.openSource(correlationId);
+					this.$logger.debug('store', 'requestOpenSource', 'response', response, correlationId);
+					const openSource = response.results ? response.results : null;
+					if (Response.hasFailed(response))
+						return response;
+					this.setOpenSource(correlationId, openSource);
+					return Response.success(correlationId, openSource);
+				},
+				async requestPlans(correlationId) {
+					const service = GlobalUtility.$injector.getService(LibraryConstants.InjectorKeys.SERVICE_PLANS);
+					const response = await service.plans(correlationId);
+					this.$logger.debug('store', 'requestPlans', 'response', response, correlationId);
+					const plans = response.results ? response.results.data : [];
+					if (Response.hasFailed(response))
+						return response;
+					this.setPlans(correlationId, plans);
+					return Response.success(plans);
+				},
+				async initialize(correlationId) {
+					const service = GlobalUtility.$injector.getService(LibraryConstants.InjectorKeys.SERVICE_UTILITY);
+					const response = await service.initialize(correlationId);
+					if (Response.hasSucceeded(response)) {
+						this.setPlans(correlationId, response.results.plans);
+						this.setVersion(correlationId, response.results.version);
+						if (this._initialize)
+							this._intialize(correlationId, response.results);
+					}
+				},
+				async requestVersion(correlationId) {
+					const service = GlobalUtility.$injector.getService(LibraryConstants.InjectorKeys.SERVICE_VERSION);
+					const version = await service.version(correlationId);
+					this.setVersion(correlationId, version);
+				},
+				async setOpenSource(correlationId, openSource) {
+					this.$logger.debug('store', 'setOpenSource', 'openSource.a', openSource, correlationId);
+					this.$logger.debug('store', 'setOpenSource', 'openSource.b', this.openSource, correlationId);
+					this.openSource = openSource;
+					this.$logger.debug('store', 'setOpenSource', 'openSource.c', this.openSource, correlationId);
+				},
+				async setPlans(correlationId, plans) {
+					this.$logger.debug('store', 'setPlans', 'plans.a', plans, correlationId);
+					this.$logger.debug('store', 'setPlans', 'plans.b', this.plans, correlationId);
+					this.plans = plans;
+					this.$logger.debug('store', 'setPlans', 'plans.c', this.plans, correlationId);
+				},
+				async setVersion(correlationId, version) {
+					// this.$logger.debug('store', 'getVersion', 'version', version, correlationId);
+					// commit('setVersion', { correlationId: correlationId, version: version });
+					this.$logger.debug('store', 'setVersion', 'version', version, correlationId);
+					this.version = version;
+				}
+			},
+			getters: {
+				getOpenSource(correlationId) {
+					return GlobalUtility.$store.openSource;
+				},
+				getPlan(correlationId, id) {
+					if (GlobalUtility.$store.plans == null)
+						return null;
+					return GlobalUtility.$store.plans.find(plan => plan.id === id);
+				}
+			},
+			dispatcher: {
+				async requestOpenSource(correlationId) {
+					return await GlobalUtility.$store.requestOpenSource(correlationId);
+				},
+				async requestPlans(correlationId) {
+					return await GlobalUtility.$store.requestPlans(correlationId);
+				},
+				async requestVersion(correlationId) {
+					await GlobalUtility.$store.requestVersion(correlationId);
+				},
+				async initialize(correlationId) {
+					await GlobalUtility.$store.initialize(correlationId);
+				}
+			}
+		};
+	}
+
 	static PersistanceTypeOverride = 'override';
 	static PersistanceTypePersist = 'persist';
 	static PersistanceTypePersist2 = 'persist2';

package/store/user/index.js

@@ -42,32 +42,28 @@ const store = {
 		async setUserLoggedIn(correlationId, isLoggedIn) {
 			this.isLoggedIn = isLoggedIn;
 		},
+		// async setUserSettings(correlationId, settings) {
+		// 	const service = GlobalUtility.$injector.getService(LibraryConstants.InjectorKeys.SERVICE_USER);
+		// 	settings = VueUtility.settings().mergeUser(correlationId, settings);
+		// 	const response = await service.updateSettings(correlationId, this.user, settings);
+		// 	this.$logger.debug('store.user', 'setUserSettings', 'response', response);
+		// 	if (Response.hasSucceeded(response) && response.results)
+		// 		this.setUser(correlationId, response.results);
+		// 	return response;
+		// },
 		async setUserSettings(correlationId, settings) {
 			const service = GlobalUtility.$injector.getService(LibraryConstants.InjectorKeys.SERVICE_USER);
-			settings = VueUtility.settings().mergeUser(params.correlationId, settings);
-			const response = await service.updateSettings(params.correlationId, this.user, settings);
+			settings = VueUtility.settings().mergeUser(correlationId, settings);
+			const response = await service.updateSettings(correlationId, this.user, settings);
 			this.$logger.debug('store.user', 'setUserSettings', 'response', response);
 			if (Response.hasSucceeded(response) && response.results)
-				this.setUser(correlationId, response.results);
+				this.user = response.results;
 			return response;
 		},
-		async setUserSettings2(correlationId, settings) {
-			const service = GlobalUtility.$injector.getService(LibraryConstants.InjectorKeys.SERVICE_USER);
-			settings = VueUtility.settings().mergeUser(params.correlationId, settings);
-			const response = await service.updateSettings(params.correlationId, this.user, settings);
-			this.$logger.debug('store.user', 'setUserSettings', 'response', response);
-			if (Response.hasSucceeded(response) && response.results) {
-				// commit('setUserSettings', { correlationId: params.correlationId, user: response.results });
-				const user = response.results;
-				user.settings = VueUtility.settings().mergeUser(correlationId, user.settings);
-				this.user = user;
-			}
-			return response;
-		},
-		async setTheme(correlationId, isLoggedIn) {
+		async setUserTheme(correlationId, isLoggedIn) {
 			this.theme = theme;
 		},
-		async setTokenResult(correlationId, tokenResult) {
+		async setUserTokenResult(correlationId, tokenResult) {
 			this.$patch({
 				tokenResult: null,
 				token: tokenResult ? tokenResult.token : null
@@ -79,42 +75,48 @@ const store = {
 			this.user = user;
 		}
 	},
+	getters: {
+		getUser (correlationId) {
+			return GlobalUtility.$store.user.user;
+		},
+		getUserTheme (correlationId) {
+			return GlobalUtility.$store.theme;
+		},
+		getUserSettings(correlationId) {
+			if (GlobalUtility.$store.user.user && GlobalUtility.$store.user.user.settings)
+				return GlobalUtility.$store.user.user.settings;
+
+			const service = GlobalUtility.$injector.getService(LibraryConstants.InjectorKeys.SERVICE_USER);
+			return service.initializeSettings();
+		}
+	},
 	dispatcher: {
 		async refreshUserSettings(correlationId) {
-			// await GlobalUtility.$store.dispatch('refreshUserSettings', correlationId);
-			await GlobalUtility.$store.user.refreshUserSettings(correlationId);
+			return await GlobalUtility.$store.user.refreshUserSettings(correlationId);
 		},
 		async resetUser(correlationId) {
-			// await GlobalUtility.$store.dispatch('resetUser', correlationId);
 			await GlobalUtility.$store.user.resetUser(correlationId);
 		},
-		async setAuthCompleted(correlationId, authCompleted) {
-			// await GlobalUtility.$store.dispatch('setUserAuthCompleted', { correlationId: correlationId, authCompleted: authCompleted });
+		async setUserAuthCompleted(correlationId, authCompleted) {
 			await GlobalUtility.$store.user.setUserAuthCompleted(correlationId, authCompleted);
 		},
-		async setClaims(correlationId, claims) {
-			// await GlobalUtility.$store.dispatch('setUserClaims', { correlationId: correlationId, authCompleted: claims });
+		async setUserClaims(correlationId, claims) {
 			await GlobalUtility.$store.user.setUserClaims(correlationId, claims);
 		},
-		async setLoggedIn(correlationId, isLoggedIn) {
-			// await GlobalUtility.$store.dispatch('setUserLoggedIn', { correlationId: correlationId, isLoggedIn: isLoggedIn });
+		async setUserLoggedIn(correlationId, isLoggedIn) {
 			await GlobalUtility.$store.user.setUserLoggedIn(correlationId, isLoggedIn);
 		},
-		async setTheme(correlationId, theme) {
-			// await GlobalUtility.$store.dispatch('setTheme', { correlationId: correlationId, tokenResult: tokenResult });
-			await GlobalUtility.$store.user.setTheme(correlationId, theme);
+		async setUserSettings(correlationId, settings) {
+			return await GlobalUtility.$store.user.setUserSettings(correlationId, settings);
+		},
+		async setUserTheme(correlationId, theme) {
+			await GlobalUtility.$store.user.setUserTheme(correlationId, theme);
 		},
-		async setTokenResult(correlationId, tokenResult) {
-			// await GlobalUtility.$store.dispatch('setTokenResult', { correlationId: correlationId, tokenResult: tokenResult });
-			await GlobalUtility.$store.user.setTokenResult(correlationId, tokenResult);
+		async setUserTokenResult(correlationId, tokenResult) {
+			await GlobalUtility.$store.user.setUserTokenResult(correlationId, tokenResult);
 		},
 		async setUser(correlationId, user) {
-			// await GlobalUtility.$store.dispatch('setUser', { correlationId: correlationId, user: user });
 			await GlobalUtility.$store.user.setUser(correlationId, user);
-		},
-		async setUserSettings(correlationId, settings) {
-			// return await GlobalUtility.$store.dispatch('setUserSettings', { correlationId: correlationId, settings: settings });
-			await GlobalUtility.$store.user.setUserSettings(correlationId, settings);
 		}
 	}
 };