@raclettejs/core 0.0.1

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

@@ -0,0 +1,76 @@
+/**
+ * data api for the store
+ */
+import getData from "@racletteCore/lib/data/fetchDataHandler"
+import handleServerItem from "./responseTypeHandler"
+import $queryApi from "./queryApi"
+import writeData from "./writeDataHandler"
+import type { CustomStoreActionsPayload } from "@racletteCore/types"
+import { BehaviorSubject } from "rxjs"
+import { clone } from "ramda"
+
+const $writeDataApi = (
+  actionId: String,
+  operationDefinition: object,
+  { params = {}, options = {} }: CustomStoreActionsPayload = {},
+) => {
+  const _params = clone(params)
+  // Create BehaviorSubjects for state management
+  const isLoadingSubject$ = new BehaviorSubject<boolean>(false)
+  const dataSubject$ = new BehaviorSubject([])
+  const errorSubject$ = new BehaviorSubject(null)
+  const writeApi = {
+    isLoading$: isLoadingSubject$.asObservable(),
+    data$: dataSubject$.asObservable(),
+    error$: errorSubject$.asObservable(),
+    execute: async (executeParams = {}) => {
+      const _executeParams = clone(executeParams)
+      errorSubject$.next(null)
+      isLoadingSubject$.next(true)
+
+      const queryParams = Object.keys(_executeParams).length
+        ? _executeParams
+        : _params
+      if (options.responseType === "stream") {
+        return writeData(actionId, operationDefinition, queryParams, options)
+      }
+      const resultData = await writeData(
+        actionId,
+        operationDefinition,
+        queryParams,
+        options,
+      ).catch((e) => {
+        const errorObj = e
+        errorSubject$.next(errorObj)
+        isLoadingSubject$.next(false)
+      })
+
+      // Update both boolean and observable on success
+      isLoadingSubject$.next(false)
+
+      // Update data if resultData is available
+      if (resultData) {
+        const dataArray = Array.isArray(resultData) ? resultData : [resultData]
+        dataSubject$.next(dataArray)
+      }
+
+      if (options.cb && typeof options.cb === "function") {
+        options.cb(resultData)
+      }
+      return resultData
+    },
+    // Method to complete the subjects when cleanup is needed
+    destroy: () => {
+      isLoadingSubject$.complete()
+      dataSubject$.complete()
+      errorSubject$.complete()
+    },
+  }
+
+  if (options.immediate === true) {
+    writeApi.execute()
+  }
+
+  return writeApi
+}
+export { handleServerItem, getData, $writeDataApi, $queryApi }

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

@@ -0,0 +1,419 @@
+import log from "@racletteCore/lib/logger"
+import { promisifyActionResolve } from "@racletteCore/lib/dataHelper"
+import { $api, $store } from "@racletteCore"
+import {
+  pluginReadOperations,
+  handleOperationTarget,
+  prefixOperationTarget,
+} from "@racletteCore/setup/plugin-system"
+import {
+  getCacheQueryAndHash,
+  isParentResultFresh,
+} from "@racletteCore/store/reducers/queriesCache/queryCacheHelper"
+
+// to be replaced with actual open search availability state
+let isOnline = true
+
+// Store active controllers for each actionId - structured for potential extraction
+const requestControllerManager = {
+  controllers: {},
+
+  create(actionId) {
+    this.abort(actionId) // Cancel existing request
+    const controller = new AbortController()
+    this.controllers[actionId] = controller
+    return controller
+  },
+
+  abort(actionId) {
+    if (this.controllers[actionId]) {
+      this.controllers[actionId].abort()
+      delete this.controllers[actionId]
+    }
+  },
+
+  cleanup(actionId) {
+    delete this.controllers[actionId]
+  },
+}
+
+type ItemDispatcherResultObject = {
+  result: Array<Object>
+  error: Object | null
+  backendQueryParams?: Object
+}
+
+type ItemDispatcherActionIdentifier = {
+  cacheKey: String
+  actionId: String
+}
+
+const itemDispatcher = async (
+  actionIdentifier: ItemDispatcherActionIdentifier = {
+    cacheKey: "",
+    actionId: "",
+  },
+  resultObj: ItemDispatcherResultObject = {
+    result: [],
+    backendQueryParams: {},
+    error: null,
+  },
+  remote: Boolean = false,
+) => {
+  const { actionId, cacheKey } = actionIdentifier
+  const { result, backendQueryParams } = resultObj
+  const resolveId = actionId + "_resolve"
+
+  if (remote) {
+    $store.dispatch({
+      type: "data/addFromServer",
+      payload: { actionIdentifier, result },
+    })
+  } else {
+    $store.dispatch({
+      type: "data/addFromClient",
+      payload: { actionIdentifier, result },
+    })
+  }
+
+  if (backendQueryParams && Object.keys(backendQueryParams).length > 0) {
+    $store.dispatch({
+      type: "queries/update",
+      payload: {
+        actionId,
+        cacheKey,
+        backend: backendQueryParams,
+      },
+    })
+  }
+
+  $store.dispatch({
+    type: "queries/updateItems",
+    payload: { items: result, actionId, cacheKey, resolveId },
+  })
+
+  if (resultObj.error) {
+    throw resultObj.error
+  }
+
+  return Promise.resolve(result.map((res) => res._source))
+}
+
+// Cache Management Functions
+const cacheOperations = {
+  async setupCache(actionId, target, params) {
+    const cachedQuery = getCacheQueryAndHash(target, params)
+    const actionIdentifier = {
+      actionId,
+      cacheKey: cachedQuery.hash,
+    }
+
+    await $store.dispatch({
+      type: "queriesCache/add",
+      payload: {
+        cacheKey: cachedQuery.hash,
+        params,
+        target,
+      },
+    })
+
+    return { cachedQuery, actionIdentifier }
+  },
+
+  async handleCacheHit(cachedQuery, actionIdentifier) {
+    if (cachedQuery.query.loading === true) {
+      // Return promise to be resolved once cache query resolves
+      return promisifyActionResolve(
+        `cacheQuery_${cachedQuery.hash}`,
+        async (result) => {
+          const items = result?.payload?.items || []
+          return await itemDispatcher(
+            actionIdentifier,
+            { result: items },
+            false,
+          )
+        },
+      )
+    }
+
+    // Return fresh cached result
+    if (isParentResultFresh(cachedQuery.hash)) {
+      const uuids = cachedQuery.query.uuids
+      const currentData = $store.getState("data")
+      const result = uuids.map((uuid) => currentData[uuid]) || []
+      return await itemDispatcher(actionIdentifier, { result }, false)
+    }
+
+    return null // No valid cache hit
+  },
+}
+
+const finishRemoteQuery = (actionIdentifier, result, params) => {
+  const { actionId, cacheKey } = actionIdentifier
+  log.api("finishRemoteQuery", { actionId, params, result })
+
+  if (!result.data) {
+    return
+  }
+
+  const resultBody = structuredClone(result.data.body)
+  const resultObj = {
+    result: [],
+    backendQueryParams: {},
+    error: result.error,
+  }
+
+  if (resultBody?.items?.length) {
+    resultBody.items.forEach((item) => resultObj.result.push(item))
+  }
+
+  if (params.stateless) {
+    return resultObj
+  }
+
+  return itemDispatcher(actionIdentifier, resultObj, true)
+}
+
+// Unified remote data handler for both GET and POST
+const handleRemoteRequest = async (
+  actionIdentifier,
+  method,
+  target,
+  params,
+  signal,
+) => {
+  const appRequestCode =
+    params.requestCode || `${method.toLowerCase()}RemoteData`
+  const config = {
+    headers: {
+      "app-request-code": appRequestCode,
+    },
+    signal,
+  }
+
+  // For GET requests, params go in config.params; for POST, they go in the body
+  if (method === "GET") {
+    config.params = params
+  }
+
+  log.api(`${method.toLowerCase()}RemoteData`, {
+    actionIdentifier,
+    target,
+    params,
+    config,
+  })
+
+  try {
+    const response =
+      method === "GET"
+        ? await $api.axios.get(target, config)
+        : await $api.axios.post(target, params, config)
+
+    return finishRemoteQuery(actionIdentifier, response, params)
+  } catch (e) {
+    if (e.name === "AbortError" || e.name === "CanceledError") {
+      log.api(`${method} request was cancelled for actionId:`, actionIdentifier)
+      throw e
+    }
+
+    log.api(`${method.toLowerCase()}RemoteData catch`, {
+      actionIdentifier,
+      target,
+      config,
+      e,
+    })
+
+    return finishRemoteQuery(
+      actionIdentifier,
+      { data: [], error: e?.response?.data || e },
+      params,
+    )
+  }
+}
+
+const searchQuery = async (
+  actionIdentifier,
+  params,
+  signal,
+  target = "auto",
+) => {
+  const { actionId, cacheKey } = actionIdentifier
+  const project = $store.getState("project")
+  const backend = $store.getState("backend")
+
+  let localProjects = params.project?.length > 0 ? params.project : project._id
+  localProjects = Array.isArray(localProjects) ? localProjects : [localProjects]
+  const projectsToQueryFrom = params.projects || localProjects
+
+  if (!params.options) {
+    params.options = {}
+  }
+
+  if (params.find) {
+    isOnline = backend?.socket?.status === 1
+    const finalParams = structuredClone(params)
+
+    if (isOnline || target === "remote" || (isOnline && target === "auto")) {
+      const query = {
+        find: finalParams.find,
+        types: finalParams.types,
+        options: finalParams.options,
+        project: projectsToQueryFrom,
+      }
+
+      log.api("searchQuery", {
+        actionIdentifier,
+        target: "core/find/query",
+        query,
+        isOnline,
+      })
+
+      return handleRemoteRequest(
+        actionIdentifier,
+        "POST",
+        "core/find/query",
+        query,
+        signal,
+      )
+    } else {
+      console.warn("no backend connection!")
+    }
+  }
+}
+
+const handlePluginReadRoutes = async (actionId, target, params) => {
+  let routeUpdated = false
+  const updatedRouteData = { actionId, target, params, validTarget: target }
+
+  if (!pluginReadOperations[actionId]) return updatedRouteData
+
+  const pluginReadOperation = pluginReadOperations[actionId]
+  const updatedTarget = prefixOperationTarget(
+    handleOperationTarget(pluginReadOperation.target, params),
+    pluginReadOperation.targetPrefix,
+  )
+
+  if (updatedTarget !== pluginReadOperation.target) {
+    updatedRouteData.validTarget = updatedTarget
+    routeUpdated = true
+  }
+
+  if (routeUpdated) {
+    await $store.dispatch({
+      type: "queries/update",
+      payload: {
+        target: updatedRouteData.validTarget,
+        actionId: actionId,
+      },
+    })
+  }
+
+  return updatedRouteData
+}
+
+// Route Handler Registry
+const routeHandlers = {
+  "remote/get": async (actionIdentifier, target, params, signal) => {
+    const cleanTarget = target.split("remote/get")[1]
+    return handleRemoteRequest(
+      actionIdentifier,
+      "GET",
+      cleanTarget,
+      params,
+      signal,
+    )
+  },
+
+  "remote/post": async (actionIdentifier, target, params, signal) => {
+    const cleanTarget = target.split("remote/post")[1]
+    return handleRemoteRequest(
+      actionIdentifier,
+      "POST",
+      cleanTarget,
+      params,
+      signal,
+    )
+  },
+
+  "search/query": async (actionIdentifier, target, params, signal) => {
+    if (params.search?.q === "@showall") {
+      const dataState = $store.getState("data")
+      return itemDispatcher(actionIdentifier, {
+        result: Object.values(dataState),
+      })
+    }
+
+    return itemDispatcher(actionIdentifier, {
+      result: [],
+    })
+  },
+}
+
+const executeRoute = async (actionIdentifier, validTarget, params) => {
+  // Find matching route handler
+  for (const [routePrefix, handler] of Object.entries(routeHandlers)) {
+    if (validTarget.indexOf(routePrefix) === 0 || validTarget === routePrefix) {
+      const controller = requestControllerManager.create(
+        actionIdentifier.actionId,
+      )
+
+      try {
+        const result = await handler(
+          actionIdentifier,
+          validTarget,
+          params,
+          controller.signal,
+        )
+        requestControllerManager.cleanup(actionIdentifier.actionId)
+        return result
+      } catch (error) {
+        requestControllerManager.cleanup(actionIdentifier.actionId)
+
+        if (error.name === "AbortError" || error.name === "CanceledError") {
+          console.log(
+            "HTTP request was cancelled for actionId:",
+            actionIdentifier.actionId,
+          )
+          throw error
+        }
+
+        throw error
+      }
+    }
+  }
+
+  // No route handler found
+  throw new Error(`No route handler found for target: ${validTarget}`)
+}
+
+const getData = async (actionId, target, params) => {
+  if (!target) {
+    return log.api("getData", "no target given", params)
+  }
+
+  // Handle plugin routing
+  const { validTarget } = await handlePluginReadRoutes(actionId, target, params)
+
+  // Setup cache
+  const { cachedQuery, actionIdentifier } = await cacheOperations.setupCache(
+    actionId,
+    validTarget,
+    params,
+  )
+
+  // Check cache
+  if (cachedQuery.query) {
+    const cacheResult = await cacheOperations.handleCacheHit(
+      cachedQuery,
+      actionIdentifier,
+    )
+    if (cacheResult !== null) {
+      return cacheResult
+    }
+  }
+
+  // Execute route
+  return executeRoute(actionIdentifier, validTarget, params)
+}
+
+export default getData

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

@@ -0,0 +1,99 @@
+/**
+ * data api for the store
+ */
+import { getData } from "@racletteCore/lib/data/dataApi"
+import { fixQueryParamTypes } from "@racletteCore/lib/dataHelper"
+import { $store, $eventbus } from "@racletteCore"
+import type { CustomStoreActionsPayload } from "@racletteCore/types"
+import { BehaviorSubject } from "rxjs"
+
+const queryApis = {}
+
+export const $queryApi = (
+  actionId: string,
+  target = "",
+  { params = {}, options = {} }: CustomStoreActionsPayload = {},
+) => {
+  if (queryApis[actionId] && !target.length) {
+    return queryApis[actionId]
+  }
+  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,
+    payload: {
+      actionId,
+      target,
+      params: cleanedParams,
+    },
+  })
+  const queryApi = {
+    error$: errorSubject$.asObservable(),
+    remove: () => {
+      $store.dispatch({
+        type: "queries/remove",
+        payload: { actionId },
+      })
+      errorSubject$.complete()
+    },
+    execute: async (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,
+          },
+        })
+      }
+      $store.dispatch({
+        type: "queries/update/loading",
+        payload: {
+          loading: true,
+          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)
+        },
+      )
+      if (options.cb && typeof options.cb === "function") {
+        options.cb(resultData)
+      }
+      return resultData
+    },
+    onDeleted: (callback) => {
+      if (callback) {
+        $eventbus.once("query_deleted_" + actionId, (query) => {
+          callback(query)
+        })
+      }
+    },
+    query$: $store.select((state) => state.queries[actionId]),
+    uuids$: $store.select((state) => state.queries[actionId].uuids),
+  }
+  if (options.immediate === true) {
+    queryApi.execute()
+  }
+
+  queryApis[actionId] = queryApi
+  return queryApi
+}
+
+export default $queryApi