@raclettejs/core 0.1.1 → 0.1.3

package/services/frontend/src/core/lib/data/fetchDataHandler.ts

@@ -39,7 +39,7 @@ const requestControllerManager = {
 
 type ItemDispatcherResultObject = {
   result: Array<Object>
-  error: Object | null
+  error?: Object | null
   backendQueryParams?: Object
 }
 
@@ -95,13 +95,21 @@ const itemDispatcher = async (
   if (resultObj.error) {
     throw resultObj.error
   }
-
+  $store.dispatch({
+    type: "queries/update/loading",
+    payload: {
+      loading: false,
+      actionId: actionId,
+    },
+  })
   return Promise.resolve(result.map((res) => res._source))
 }
 
 // Cache Management Functions
 const cacheOperations = {
-  async setupCache(actionId, target, params) {
+  async setupCache(actionId, target, params, options) {
+    if (options.useStore === false)
+      return { cachedQuery: null, actionIdentifier: { actionId } }
     const cachedQuery = getCacheQueryAndHash(target, params)
     const actionIdentifier = {
       actionId,
@@ -148,7 +156,7 @@ const cacheOperations = {
   },
 }
 
-const finishRemoteQuery = (actionIdentifier, result, params) => {
+const finishRemoteQuery = (actionIdentifier, result, params, options) => {
   const { actionId, cacheKey } = actionIdentifier
   log.api("finishRemoteQuery", { actionId, params, result })
 
@@ -167,8 +175,15 @@ const finishRemoteQuery = (actionIdentifier, result, params) => {
     resultBody.items.forEach((item) => resultObj.result.push(item))
   }
 
-  if (params.stateless) {
-    return resultObj
+  if (options.useStore === false) {
+    $store.dispatch({
+      type: "queries/update/loading",
+      payload: {
+        loading: false,
+        actionId: actionId,
+      },
+    })
+    return result.data
   }
 
   return itemDispatcher(actionIdentifier, resultObj, true)
@@ -180,6 +195,7 @@ const handleRemoteRequest = async (
   method,
   target,
   params,
+  options,
   signal,
 ) => {
   const appRequestCode =
@@ -209,7 +225,7 @@ const handleRemoteRequest = async (
         ? await $api.axios.get(target, config)
         : await $api.axios.post(target, params, config)
 
-    return finishRemoteQuery(actionIdentifier, response, params)
+    return finishRemoteQuery(actionIdentifier, response, params, options)
   } catch (e) {
     if (e.name === "AbortError" || e.name === "CanceledError") {
       log.api(`${method} request was cancelled for actionId:`, actionIdentifier)
@@ -227,6 +243,7 @@ const handleRemoteRequest = async (
       actionIdentifier,
       { data: [], error: e?.response?.data || e },
       params,
+      options,
     )
   }
 }
@@ -234,6 +251,7 @@ const handleRemoteRequest = async (
 const searchQuery = async (
   actionIdentifier,
   params,
+  options,
   signal,
   target = "auto",
 ) => {
@@ -273,6 +291,7 @@ const searchQuery = async (
         "POST",
         "core/find/query",
         query,
+        options,
         signal,
       )
     } else {
@@ -313,43 +332,53 @@ const handlePluginReadRoutes = async (actionId, target, params) => {
 
 // Route Handler Registry
 const routeHandlers = {
-  "remote/get": async (actionIdentifier, target, params, signal) => {
+  "remote/get": async (actionIdentifier, target, params, options, signal) => {
     const cleanTarget = target.split("remote/get")[1]
     return handleRemoteRequest(
       actionIdentifier,
       "GET",
       cleanTarget,
       params,
+      options,
       signal,
     )
   },
 
-  "remote/post": async (actionIdentifier, target, params, signal) => {
+  "remote/post": async (actionIdentifier, target, params, options, signal) => {
     const cleanTarget = target.split("remote/post")[1]
     return handleRemoteRequest(
       actionIdentifier,
       "POST",
       cleanTarget,
       params,
+      options,
       signal,
     )
   },
 
-  "search/query": async (actionIdentifier, target, params, signal) => {
+  "search/query": async (actionIdentifier, target, params, options, signal) => {
     if (params.search?.q === "@showall") {
       const dataState = $store.getState("data")
-      return itemDispatcher(actionIdentifier, {
-        result: Object.values(dataState),
-      })
+      return itemDispatcher(
+        actionIdentifier,
+        {
+          result: Object.values(dataState),
+        },
+        true,
+      )
     }
 
-    return itemDispatcher(actionIdentifier, {
-      result: [],
-    })
+    return itemDispatcher(
+      actionIdentifier,
+      {
+        result: [],
+      },
+      true,
+    )
   },
 }
 
-const executeRoute = async (actionIdentifier, validTarget, params) => {
+const executeRoute = async (actionIdentifier, validTarget, params, options) => {
   // Find matching route handler
   for (const [routePrefix, handler] of Object.entries(routeHandlers)) {
     if (validTarget.indexOf(routePrefix) === 0 || validTarget === routePrefix) {
@@ -362,6 +391,7 @@ const executeRoute = async (actionIdentifier, validTarget, params) => {
           actionIdentifier,
           validTarget,
           params,
+          options,
           controller.signal,
         )
         requestControllerManager.cleanup(actionIdentifier.actionId)
@@ -386,7 +416,7 @@ const executeRoute = async (actionIdentifier, validTarget, params) => {
   throw new Error(`No route handler found for target: ${validTarget}`)
 }
 
-const getData = async (actionId, target, params) => {
+const getData = async (actionId, target, params, options) => {
   if (!target) {
     return log.api("getData", "no target given", params)
   }
@@ -399,10 +429,11 @@ const getData = async (actionId, target, params) => {
     actionId,
     validTarget,
     params,
+    options,
   )
 
   // Check cache
-  if (cachedQuery.query) {
+  if (cachedQuery?.query) {
     const cacheResult = await cacheOperations.handleCacheHit(
       cachedQuery,
       actionIdentifier,
@@ -411,9 +442,8 @@ const getData = async (actionId, target, params) => {
       return cacheResult
     }
   }
-
   // Execute route
-  return executeRoute(actionIdentifier, validTarget, params)
+  return executeRoute(actionIdentifier, validTarget, params, options)
 }
 
 export default getData

package/services/frontend/src/core/lib/data/queryApi.ts

@@ -6,6 +6,7 @@ import { fixQueryParamTypes } from "@racletteCore/lib/dataHelper"
 import { $store, $eventbus } from "@racletteCore"
 import type { CustomStoreActionsPayload } from "@racletteCore/types"
 import { BehaviorSubject } from "rxjs"
+import { mergeDeepRight, clone } from "ramda"
 
 const queryApis = {}
 
@@ -17,15 +18,12 @@ export const $queryApi = (
   if (queryApis[actionId] && !target.length) {
     return queryApis[actionId]
   }
+  const errorSubject$ = new BehaviorSubject(null)
+  const resultSubject$ = new BehaviorSubject({})
   const cleanedParams = fixQueryParamTypes(params)
-
-  if (params.stateless === true) {
-    return getData(actionId, target, cleanedParams)
-  }
   // check if we have a query fullfilling the needs of the one requested
   // here. If not we will update the one with this actionId
   let actionType = "queries/add"
-  const errorSubject$ = new BehaviorSubject(null)
 
   $store.dispatch({
     type: actionType,
@@ -37,6 +35,9 @@ export const $queryApi = (
   })
   const queryApi = {
     error$: errorSubject$.asObservable(),
+    result$: resultSubject$.asObservable(),
+    query$: $store.select((state) => state.queries[actionId]),
+    uuids$: $store.select((state) => state.queries[actionId].uuids),
     remove: () => {
       $store.dispatch({
         type: "queries/remove",
@@ -45,18 +46,10 @@ export const $queryApi = (
       errorSubject$.complete()
     },
     execute: async (executeParams = {}) => {
+      const _executeParams = clone(executeParams)
       errorSubject$.next(null)
-      if (Object.keys(executeParams).length) {
-        // if our target changed we want to update it in the store
-        $store.dispatch({
-          type: "queries/update",
-          payload: {
-            params: executeParams,
-            reset: true,
-            actionId: actionId,
-          },
-        })
-      }
+      resultSubject$.next({})
+      const queryParams = mergeDeepRight(cleanedParams, _executeParams)
       $store.dispatch({
         type: "queries/update/loading",
         payload: {
@@ -64,15 +57,17 @@ export const $queryApi = (
           actionId: actionId,
         },
       })
-      const queryParams = Object.keys(executeParams).length
-        ? executeParams
-        : cleanedParams
-      const resultData = await getData(actionId, target, queryParams).catch(
-        (e) => {
-          const errorObj = e
-          errorSubject$.next(errorObj)
-        },
-      )
+
+      const resultData = await getData(
+        actionId,
+        target,
+        queryParams,
+        options,
+      ).catch((e) => {
+        const errorObj = e
+        errorSubject$.next(errorObj)
+      })
+      resultSubject$.next(resultData)
       if (options.cb && typeof options.cb === "function") {
         options.cb(resultData)
       }
@@ -85,8 +80,6 @@ export const $queryApi = (
         })
       }
     },
-    query$: $store.select((state) => state.queries[actionId]),
-    uuids$: $store.select((state) => state.queries[actionId].uuids),
   }
   if (options.immediate === true) {
     queryApi.execute()

package/services/frontend/src/core/setup/plugin-system/api/plugin-data.ts

@@ -1,6 +1,7 @@
 import { getInstanceActionId } from "@shared/helper/pluginHelper"
 import { i18nInstance } from "@racletteOrchestrator"
 import { v4 as uuidv4 } from "uuid"
+import { nanoid } from "nanoid"
 import type { Plugin } from "vue"
 import type {
   CustomStoreActionsPayload,
@@ -76,15 +77,17 @@ export const handlePluginOperations =
           if (actionIdOverride.length) actionIdBase = actionIdOverride
           const actionId = createPluginActionId(dataTypeName, actionIdBase)
           storeActionTypeStoreActions[customOperationName] = ({
+            id = nanoid(4),
             params = {},
             options = {},
           }: CustomStoreActionsPayload = {}) => {
-            const instanceActionId = getInstanceActionId(
-              prefixedPluginName,
-              instanceId,
-              actionId,
-              actionIdOverride,
-            )
+            const instanceActionId =
+              getInstanceActionId(
+                prefixedPluginName,
+                instanceId,
+                actionId,
+                actionIdOverride,
+              ) + `-${id}`
             if (!params._id && options.immediate === true) {
               params._id = uuidv4()
             }
@@ -108,15 +111,17 @@ export const handlePluginOperations =
           const actionId = createPluginActionId(dataTypeName, actionIdBase)
 
           storeActionTypeStoreActions[customOperationName] = ({
+            id = nanoid(4),
             params = {},
             options = {},
           }: CustomStoreActionsPayload = {}) => {
-            const instanceActionId = getInstanceActionId(
-              prefixedPluginName,
-              instanceId,
-              actionId,
-              actionIdOverride,
-            )
+            const instanceActionId =
+              getInstanceActionId(
+                prefixedPluginName,
+                instanceId,
+                actionId,
+                actionIdOverride,
+              ) + `-${id}`
             const method = customOperation.method || "get"
             let target = handleOperationTarget(customOperation.target, params)
 
@@ -130,7 +135,6 @@ export const handlePluginOperations =
             }
             // todo remove this singleton and pass the operationConfig to the query state as we need it in the fetch handler, also if it is called by the query effect
             addPluginReadOperation(instanceActionId, operationConfig)
-
             return orchestratorResultWrapper.read(instanceActionId, target, {
               params,
               options,

package/services/frontend/src/core/types/DataApi.ts

@@ -10,9 +10,21 @@ export type CustomStoreActionOptions = {
 }
 
 export type CustomStoreActionsPayload = {
+  id?: String // if set this will used as the final namespace giver for the actionId, if not it will be a nanoId
   params?: CustomStoreActionParams
   options?: CustomStoreActionOptions
 }
 export type QueryApiQuery = QueryState & {
-  execute: (params?: Record<string, any>) => void
+  execute: (params?: Record<string, any>) => Promise<any>
+}
+export type DataApiMethods = {
+  data: Object
+  error: Object
+  response: Object
+  isLoading: Boolean
+  execute: Function
+}
+export type QueryMethods = DataApiMethods & {
+  uuids: Array<string>
+  query: Object
 }

package/services/frontend/src/orchestrator/composables/useVueQueryObservableHelper.ts

@@ -4,6 +4,7 @@ import { $queryApi } from "@racletteCore/lib/data/dataApi"
 import type {
   CustomStoreActionsPayload,
   QueryApiQuery,
+  QueryMethods,
 } from "@racletteCore/types"
 import { difference } from "ramda"
 import getStateObservable from "@racletteCore/lib/observableHelpers/getStateObservable"
@@ -16,7 +17,7 @@ export const useVueQueryObservableHelper = (
   instanceActionId,
   target,
   { params = {}, options = {} }: CustomStoreActionsPayload = {},
-) => {
+): QueryMethods => {
   const dataObservable$ = ref<Observable<unknown>>()
 
   const data = computed(() => {
@@ -40,17 +41,24 @@ export const useVueQueryObservableHelper = (
   subscriber$[instanceActionId] = coreQuery
   const queryRef = useObservable<QueryApiQuery>(coreQuery.query$)
   const errorObservable = useObservable(coreQuery.error$)
+  const resultRef = useObservable<QueryApiQuery>(coreQuery.result$)
+  if (options.useStore !== false) {
+    watch(queryRef, (value, oldValue) => {
+      const newUUIDS = value?.uuids || []
+      const oldUUIDS = oldValue?.uuids || []
+      if (
+        difference(newUUIDS, oldUUIDS).length ||
+        difference(oldUUIDS || [], newUUIDS).length
+      ) {
+        dataObservable$.value = getStateObservable([
+          "data",
+          newUUIDS,
+          "_source",
+        ])
+      }
+    })
+  }
 
-  watch(queryRef, (value, oldValue) => {
-    const newUUIDS = value?.uuids || []
-    const oldUUIDS = oldValue?.uuids || []
-    if (
-      difference(newUUIDS, oldUUIDS).length ||
-      difference(oldUUIDS || [], newUUIDS).length
-    ) {
-      dataObservable$.value = getStateObservable(["data", newUUIDS, "_source"])
-    }
-  })
   onUnmounted(() => {
     subscriberCounter[instanceActionId] -= 1
     if (subscriberCounter[instanceActionId] === 0) {
@@ -65,11 +73,13 @@ export const useVueQueryObservableHelper = (
       return queryRef.value?.loading
     }),
     data,
+    response: resultRef,
     execute: coreQuery.execute,
     uuids: coreQuery.uuids$,
     error: computed(() => {
       return errorObservable.value
     }),
   }
+  if (options.useStore === false) delete queryObject.uuids
   return queryObject
 }

package/services/frontend/src/orchestrator/composables/useVueWriteOperationHelper.ts

@@ -1,7 +1,10 @@
 import { computed, ref, watch, onUnmounted } from "vue"
 import { useObservable } from "@vueuse/rxjs"
 import { $writeDataApi } from "@racletteCore/lib/data/dataApi"
-import type { CustomStoreActionsPayload } from "@racletteCore/types"
+import type {
+  CustomStoreActionsPayload,
+  DataApiMethods,
+} from "@racletteCore/types"
 import getStateObservable from "@racletteCore/lib/observableHelpers/getStateObservable"
 import type { Observable } from "rxjs"
 
@@ -12,10 +15,11 @@ export const useVueWriteOperationHelper = (
   instanceActionId,
   operationDefinition,
   { params = {}, options = {} }: CustomStoreActionsPayload = {},
-) => {
+): DataApiMethods => {
   let writeOperation
-  const dataStoreObservable$ = ref<Observable<unknown>>()
-  const storeData = computed(() => {
+  const dataStoreObservable$ = ref<Observable<any>>()
+
+  const data = computed(() => {
     if (dataStoreObservable$.value) {
       const result = useObservable(dataStoreObservable$.value).value
       return result
@@ -23,6 +27,7 @@ export const useVueWriteOperationHelper = (
 
     return null
   })
+
   if (subscriber$[instanceActionId]) {
     subscriberCounter[instanceActionId] += 1
     writeOperation = subscriber$[instanceActionId]
@@ -40,6 +45,22 @@ export const useVueWriteOperationHelper = (
   const isLoadingObservable = useObservable(writeOperation.isLoading$)
   const dataObservable = useObservable(writeOperation.data$)
   const errorObservable = useObservable(writeOperation.error$)
+  const resultRef = useObservable(writeOperation.result$)
+  if (options.useStore !== false) {
+    watch(dataObservable, (value, oldValue) => {
+      const uuids = []
+      if (dataObservable.value && Array.isArray(dataObservable.value)) {
+        dataObservable.value.forEach((item) => {
+          uuids.push(item._id)
+        })
+        dataStoreObservable$.value = getStateObservable([
+          "data",
+          uuids,
+          "_source",
+        ])
+      }
+    })
+  }
 
   onUnmounted(() => {
     subscriberCounter[instanceActionId] -= 1
@@ -58,20 +79,8 @@ export const useVueWriteOperationHelper = (
     isLoading: computed(() => {
       return isLoadingObservable.value
     }),
-    data: computed(() => {
-      const uuids = []
-      if (dataObservable.value && Array.isArray(dataObservable.value)) {
-        dataObservable.value.forEach((item) => {
-          uuids.push(item._id)
-        })
-        dataStoreObservable$.value = getStateObservable([
-          "data",
-          uuids,
-          "_source",
-        ])
-      }
-      return storeData.value || []
-    }),
+    data,
+    response: resultRef,
     execute: writeOperation.execute,
     error: computed(() => {
       return errorObservable.value

package/services/frontend/src/orchestrator/types/PluginApi.ts

@@ -1,5 +1,5 @@
 import type { useI18n } from "vue-i18n"
-import type { ComputedRef } from "vue"
+import type { ComputedRef, Ref } from "vue"
 import type { CorePluginApi } from "@racletteCore/main"
 import type {
   CustomStoreActionsPayload,
@@ -11,11 +11,15 @@ import type { Socket } from "socket.io-client"
 import type { User } from "@shared/types"
 // TODO: finalize types
 // TODO: generate this type from index.ts in the plugin & extend it globally
-
 export type PluginMethod = (payload?: CustomStoreActionsPayload) => {
-  query: Query
+  isLoading: Boolean
+  response: Ref<unknown>
+  error: Ref<unknown>
   data: ComputedRef<unknown>
   execute: (params?: Record<string, any>) => void
+  // query and uuids only provided from queryObservableHelper
+  query?: ComputedRef<Query>
+  uuids?: Array<string>
   // TODO: implement this in the useVueQueryObservableHelper remove: () => void
 }
 export type PluginSocketApi = {