@raclettejs/core 0.1.36 → 0.1.38

package/services/frontend/src/core/store/reducers/queries/reducers.ts

@@ -3,9 +3,9 @@
  */
 
 import { fixQueryParamTypes } from "@racletteCore/lib/dataHelper"
-import { difference, mergeDeepRight, filter } from "ramda"
+import { difference, mergeDeepRight } from "ramda"
 import type { CustomStoreActionParams } from "@racletteCore/types"
-import { $eventbus, $store } from "@racletteCore/main"
+
 export type Query = {
   target: string
   actionId: string
@@ -22,8 +22,7 @@ const updateQueryItems = (state, action) => {
   if (!actionId || !state[actionId]) {
     return state
   }
-  const queries = structuredClone(state)
-  const query = queries[actionId]
+  const query = { ...state[actionId] }
   if (items) {
     const uuids = Object.values(items).map((item) => item._id)
     let dataItemsToRemove = []
@@ -35,15 +34,14 @@ const updateQueryItems = (state, action) => {
     query.loading = false
     query.uuids = uuids
     if (dataItemsToRemove.length > 0) {
-      $store.dispatch({
-        type: "data/deleteFromCache",
-        payload: { uuids: dataItemsToRemove },
-        actionId: actionId,
-      })
+      action.actionResult.dataCacheCleanup = {
+        actionId,
+        uuids: dataItemsToRemove,
+      }
     }
   }
 
-  return queries
+  return { ...state, [actionId]: query }
 }
 
 const updateQuery = (state, action) => {
@@ -53,8 +51,7 @@ const updateQuery = (state, action) => {
     return state
   }
 
-  let queries = structuredClone(state)
-  const query = queries[actionId]
+  const query = { ...state[actionId] }
   if (payload.target) {
     query.target = payload.target
   }
@@ -106,20 +103,19 @@ const updateQuery = (state, action) => {
     query.backend = fixQueryParamTypes(query.backend)
   }
 
-  return queries
+  return { ...state, [actionId]: query }
 }
 const queryiesSetCacheKey = (state, action) => {
-  let queries = structuredClone(state)
   const payload = action.payload
   const { actionId, cacheKey } = payload
   if (!actionId || !state[actionId]) {
     return state
   }
 
-  queries[actionId] = { ...queries[actionId], cacheKey }
+  const updatedQuery = { ...state[actionId], cacheKey }
   action.actionResult.updated.itemBefore = state[actionId]
-  action.actionResult.updated.item = queries[actionId]
-  return queries
+  action.actionResult.updated.item = updatedQuery
+  return { ...state, [actionId]: updatedQuery }
 }
 const queriesUpdateLoading = (state, action) => {
   const payload = action.payload
@@ -127,12 +123,13 @@ const queriesUpdateLoading = (state, action) => {
   if (!actionId || !state[actionId]) {
     return state
   }
-  const queries = structuredClone(state)
-  const query = queries[actionId]
-  if (payload.hasOwnProperty("loading")) {
-    query.loading = payload.loading
+  if (!payload.hasOwnProperty("loading")) {
+    return state
+  }
+  return {
+    ...state,
+    [actionId]: { ...state[actionId], loading: payload.loading },
   }
-  return queries
 }
 /**
  * execute queries
@@ -141,14 +138,11 @@ const queriesExecute = (state, action) => {
   if (Object.keys(state).length === 0) {
     return state
   }
-  const { target, params, actionId, reset, type } = structuredClone(
-    action.payload,
-  )
+  const { target, params, actionId, reset, type } = action.payload
   const isResetQuery = reset || params?.reset
-  const queries = structuredClone(state)
 
-  if (actionId && queries[actionId]) {
-    const query = queries[actionId]
+  if (actionId && state[actionId]) {
+    const query = { ...state[actionId] }
 
     query.loading = true
     action.actionResult.updated.itemsBefore[actionId] = state[actionId]
@@ -166,24 +160,27 @@ const queriesExecute = (state, action) => {
     }
     query.params = fixQueryParamTypes(query.params)
     action.actionResult.updated.items[actionId] = query
-    queries[actionId] = query
-  } else {
-    Object.keys(queries).forEach((actionId) => {
-      const query = queries[actionId]
-      action.actionResult.updated.itemsBefore[actionId] = state[actionId]
-      if (
-        !type ||
-        (type === "find" && query.params.find) ||
-        (type === "search" && query.params.search)
-      ) {
-        query.loading = true
-        query.params = fixQueryParamTypes(query.params)
-        action.actionResult.updated.itemsBefore[actionId] = state[actionId]
-        action.actionResult.updated.items[actionId] = query
-      }
-    })
+
+    return { ...state, [actionId]: query }
   }
 
+  const queries = structuredClone(state)
+
+  Object.keys(queries).forEach((queryActionId) => {
+    const query = queries[queryActionId]
+    action.actionResult.updated.itemsBefore[queryActionId] = state[queryActionId]
+    if (
+      !type ||
+      (type === "find" && query.params.find) ||
+      (type === "search" && query.params.search)
+    ) {
+      query.loading = true
+      query.params = fixQueryParamTypes(query.params)
+      action.actionResult.updated.itemsBefore[queryActionId] = state[queryActionId]
+      action.actionResult.updated.items[queryActionId] = query
+    }
+  })
+
   return queries
 }
 /**
@@ -209,36 +206,37 @@ const queriesAdd = (state, action) => {
   }
 
   action.actionResult.added.push(query)
-  const queries = structuredClone(state)
-  queries[actionId] = query
 
-  return queries
+  return { ...state, [actionId]: query }
 }
 
 /**
  * remove queries
  */
 const queriesRemove = (state, action) => {
-  let queries = structuredClone(state)
   const { actionId } = action.payload
-  if (actionId && queries[actionId]) {
-    const query = queries[actionId] || {}
-    action.actionResult.deleted.hard[actionId] = query
-    if (query?.uuids?.length) {
-      // when we delete a query we will now have to remove all data Items which have been retrieven ONLY for this query. This will be determined in dataDelete reducer
-      $store.dispatch({
-        type: "data/deleteFromCache",
-        payload: { uuids: query.uuids },
-        actionId: actionId,
-      })
+  if (!actionId || !state[actionId]) {
+    return state
+  }
+
+  const query = state[actionId]
+  action.actionResult.deleted.hard[actionId] = query
+  if (query?.uuids?.length) {
+    action.actionResult.dataCacheCleanup = {
+      actionId,
+      uuids: query.uuids,
     }
+  }
 
-    $eventbus.emit("query_deleted_" + actionId, structuredClone(query))
-    // check for parent query and if there are more than this actionId childs of it
-    delete queries[actionId]
+  action.actionResult.queryDeleted = {
+    actionId,
+    query: structuredClone(query),
   }
 
-  return queries || {}
+  const queries = { ...state }
+  delete queries[actionId]
+
+  return queries
 }
 
 export {

package/services/frontend/src/core/store/reducers/queriesCache/effects.ts

@@ -0,0 +1,105 @@
+import { tap, distinctUntilChanged, ignoreElements } from "rxjs/operators"
+import { actions$, ofType } from "mini-rx-store"
+import log from "@racletteCore/lib/logger"
+import {
+  scheduleAfterPaint,
+  scheduleIdleWork,
+} from "@racletteCore/lib/scheduleTask"
+
+const GRACE_PERIOD_MS = 500
+const deleteTimeouts: Record<string, ReturnType<typeof setTimeout>> = {}
+
+const clearGraceTimeout = (cacheKey: string) => {
+  if (deleteTimeouts[cacheKey]) {
+    clearTimeout(deleteTimeouts[cacheKey])
+    delete deleteTimeouts[cacheKey]
+  }
+}
+
+const queriesCacheEffects = (store) => {
+  const queriesCacheScheduleGraceEviction = actions$.pipe(
+    ofType("queries/remove"),
+    distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
+
+    tap((action) => {
+      const grace = action.actionResult?.cacheGraceEviction as
+        | { cacheKey: string; actionId: string }
+        | undefined
+
+      if (!grace?.cacheKey) {
+        return
+      }
+
+      clearGraceTimeout(grace.cacheKey)
+      deleteTimeouts[grace.cacheKey] = setTimeout(() => {
+        delete deleteTimeouts[grace.cacheKey]
+        scheduleAfterPaint(() => {
+          store.dispatch({
+            type: "queriesCache/remove",
+            payload: { cacheKey: grace.cacheKey, actionId: grace.actionId },
+          })
+        })
+      }, GRACE_PERIOD_MS)
+    }),
+    ignoreElements(),
+  )
+
+  const queriesCacheCancelGraceEviction = actions$.pipe(
+    ofType("queriesCache/add"),
+    distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
+
+    tap((action) => {
+      const cancel = action.actionResult?.cacheGraceCancel as
+        | { cacheKey: string }
+        | undefined
+
+      if (cancel?.cacheKey) {
+        clearGraceTimeout(cancel.cacheKey)
+      }
+    }),
+    ignoreElements(),
+  )
+
+  const queriesCacheEvictData = actions$.pipe(
+    ofType("queriesCache/remove"),
+    distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
+
+    tap((action) => {
+      const cancelled = action.actionResult?.cacheRemoveCancelled as
+        | { cacheKey: string; childCount: number }
+        | undefined
+
+      if (cancelled) {
+        log.store(
+          "cacheRemove",
+          `the cache with hash ${cancelled.cacheKey} is still/again in use by ${cancelled.childCount} queries`,
+        )
+      }
+
+      const eviction = action.actionResult?.cacheEviction as
+        | { cacheKey: string; uuids: string[] }
+        | undefined
+
+      if (!eviction?.uuids?.length) {
+        return
+      }
+
+      scheduleIdleWork(() => {
+        store.dispatch({
+          type: "data/deleteFromCache",
+          actionId: eviction.cacheKey,
+          payload: { uuids: eviction.uuids },
+        })
+      })
+    }),
+    ignoreElements(),
+  )
+
+  return [
+    queriesCacheScheduleGraceEviction,
+    queriesCacheCancelGraceEviction,
+    queriesCacheEvictData,
+  ]
+}
+
+export default queriesCacheEffects

package/services/frontend/src/core/store/reducers/queriesCache/index.ts

@@ -1,6 +1,7 @@
 import reducerFromMap from "@racletteCore/lib/reducerFromMap"
 import { applicationState } from "@racletteCore/store/state"
 import * as reducers from "./reducers"
+import queriesCacheEffects from "./effects"
 
 const reducerMap = {
   init: () => applicationState.queriesCache || {},
@@ -12,4 +13,4 @@ const reducerMap = {
 
 const queriesCacheReducers = reducerFromMap(reducerMap)
 
-export { queriesCacheReducers }
+export { queriesCacheEffects, queriesCacheReducers }

package/services/frontend/src/core/store/reducers/queriesCache/queryCacheHelper.ts

@@ -2,15 +2,82 @@ import createStableHash from "@racletteCore/lib/createStableHash"
 import { $store } from "@racletteCore"
 import log from "@racletteCore/lib/logger"
 
-const isParentResultFresh = (cacheKey: string, ttl: number = 1000): boolean => {
-  const queriesState = $store.getState("queriesCache")
-  const currentTimeStamp = new Date().getTime()
+export type ParentQuery = {
+  cacheKey: string
+  loading?: boolean
+  uuids?: Array<string>
+  lastFetched?: number
+  deleted?: boolean
+}
+
+type QueryRef = {
+  target: string
+  params: Record<string, unknown>
+}
+
+const DEFAULT_TTL_MS = 1000
+
+const countChildQueriesForCacheKey = (
+  queries: Record<string, QueryRef>,
+  cacheKey: string,
+): number => {
+  let count = 0
+  Object.values(queries).forEach((query) => {
+    const queryCacheKey = createStableHash({
+      target: query.target,
+      params: query.params,
+    })
+    if (cacheKey === queryCacheKey) {
+      count++
+    }
+  })
+  return count
+}
+
+const getCacheEntryForRemovedQuery = (
+  queriesCache: Record<string, ParentQuery>,
+  removedQuery: QueryRef | null | undefined,
+): { cacheKey: string; entry: ParentQuery } | null => {
+  if (!removedQuery) {
+    return null
+  }
+
+  const cacheKey = createStableHash({
+    target: removedQuery.target,
+    params: removedQuery.params,
+  })
+  const entry = queriesCache[cacheKey]
+
+  if (!entry) {
+    return null
+  }
+
+  return { cacheKey, entry }
+}
+
+const isCacheEntryFresh = (
+  entry: ParentQuery | undefined,
+  ttl: number = DEFAULT_TTL_MS,
+  now: number = Date.now(),
+): boolean => {
+  if (
+    !entry?.lastFetched ||
+    !entry?.uuids ||
+    entry.loading === true
+  ) {
+    return false
+  }
+
+  return entry.lastFetched + ttl >= now
+}
+
+const isParentResultFresh = (cacheKey: string, ttl: number = DEFAULT_TTL_MS): boolean => {
+  const queriesState = $store.getState("queriesCache") as Record<string, ParentQuery>
   const parentQuery = queriesState[cacheKey]
 
   if (
-    !parentQuery.lastFetched ||
-    !parentQuery.uuids ||
-    parentQuery.hasOwnProperty("loading") === false ||
+    !parentQuery?.lastFetched ||
+    !parentQuery?.uuids ||
     parentQuery.loading === true
   ) {
     log.store(
@@ -21,14 +88,14 @@ const isParentResultFresh = (cacheKey: string, ttl: number = 1000): boolean => {
     return false
   }
 
-  const isParentResultFresh = parentQuery.lastFetched + ttl >= currentTimeStamp
+  const fresh = isCacheEntryFresh(parentQuery, ttl)
 
   log.store(
     "queryCacheHelper",
-    `cache #${cacheKey} is ${isParentResultFresh ? "fresh" : "stale"} for ttl of ${ttl}ms`,
+    `cache #${cacheKey} is ${fresh ? "fresh" : "stale"} for ttl of ${ttl}ms`,
   )
 
-  return isParentResultFresh
+  return fresh
 }
 
 const getParentActionIdHash = (
@@ -62,6 +129,9 @@ const hasCacheQuery = (
 }
 
 export {
+  countChildQueriesForCacheKey,
+  getCacheEntryForRemovedQuery,
+  isCacheEntryFresh,
   getCacheQueryAndHash,
   hasCacheQuery,
   getParentActionIdHash,

package/services/frontend/src/core/store/reducers/queriesCache/reducers.ts

@@ -1,135 +1,130 @@
 import createStableHash from "@racletteCore/lib/createStableHash"
-import log from "@racletteCore/lib/logger"
-import { $store } from "@racletteCore"
-import { isParentResultFresh } from "./queryCacheHelper"
-const deleteTimeouts = {}
-export type ParentQuery = {
-  cacheKey: string
-  loading?: boolean
-  uuids?: Array<string>
-  lastFetched?: number
-  deleted?: boolean
-}
-const cacheMap = {}
-const getAffectedCacheQuery = (state, actionId) => {
-  const removedQuery = $store.getState(["queries", actionId])
-  if (!removedQuery) {
-    return null
-  }
-  const removedQueryCacheKey = createStableHash({
-    target: removedQuery.target,
-    params: removedQuery.params,
-  })
-  return state[removedQueryCacheKey]
-}
-const getChildQueries = (cacheKey: string): Array<Record<string, object>> => {
-  const queries = $store.getState("queries")
-  const childQueries = []
-  Object.values(queries).forEach((query) => {
-    const queryCacheKey = createStableHash({
-      target: query.target,
-      params: query.params,
-    })
-    if (cacheKey === queryCacheKey) {
-      childQueries.push(query)
-    }
-  })
-  return childQueries
-}
+import {
+  countChildQueriesForCacheKey,
+  getCacheEntryForRemovedQuery,
+  isCacheEntryFresh,
+  type ParentQuery,
+} from "./queryCacheHelper"
+
+export type { ParentQuery }
+
 const cacheAdd = (state, action) => {
-  const newState = structuredClone(state)
   const { payload } = action
   const { target, params, cacheKey } = payload
-  const parentQueryContent = {
-    cacheKey,
-    loading: true,
-  }
   const hash =
     cacheKey ||
     createStableHash({
       target,
       params,
     })
-  if (!newState[hash]) {
-    newState[hash] = parentQueryContent
-  } else {
-    if (newState[hash].deleted) {
-      if (!isParentResultFresh(hash)) {
-        // it seems that this chache got requested again during it's grace delte time period. So Let's just set our loading state to true and delete the delete flag
-        newState[hash].loading = true
-      }
-
-      delete newState[hash].deleted
+  const existing = state[hash]
+
+  if (!existing) {
+    return {
+      ...state,
+      [hash]: {
+        cacheKey,
+        loading: true,
+      },
     }
   }
 
-  return newState
+  if (!existing.deleted) {
+    return state
+  }
+
+  action.actionResult.cacheGraceCancel = { cacheKey: hash }
+
+  const updated = { ...existing }
+  if (!isCacheEntryFresh(existing)) {
+    // it seems that this chache got requested again during it's grace delte time period. So Let's just set our loading state to true and delete the delete flag
+    updated.loading = true
+  }
+  delete updated.deleted
+
+  return { ...state, [hash]: updated }
 }
+
 const cacheCheck = (state: Record<string, ParentQuery>, action) => {
-  const newState = structuredClone(state)
-
-  const { items, cacheKey, actionId } = action.payload
-  cacheMap[actionId] = cacheKey
-  const affectedCacheQuery = newState[cacheKey]
-  if (affectedCacheQuery) {
-    affectedCacheQuery.loading = false
-    affectedCacheQuery.lastFetched = new Date().getTime()
-    action.actionResult.relationships.resolved.push(`cacheQuery_${cacheKey}`)
-    if (items) {
-      affectedCacheQuery.uuids = Object.values(items).map((item) => item._id)
-    }
+  const { items, cacheKey } = action.payload
+  const affectedCacheQuery = state[cacheKey]
+  if (!affectedCacheQuery) {
+    return state
   }
 
-  return newState
+  const updated: ParentQuery = {
+    ...affectedCacheQuery,
+    loading: false,
+    lastFetched: new Date().getTime(),
+  }
+  action.actionResult.relationships.resolved.push(`cacheQuery_${cacheKey}`)
+  if (items) {
+    updated.uuids = (Object.values(items) as Array<{ _id: string }>).map(
+      (item) => item._id,
+    )
+  }
+
+  return { ...state, [cacheKey]: updated }
 }
+
 const cacheRemove = (state, action) => {
-  const newState = structuredClone(state)
   const { cacheKey } = action.payload
-  const childQueries = getChildQueries(cacheKey)
-  if (childQueries.length === 0) {
-    // We have no further childs for this cache, so we will delete it and it's items
-    $store.dispatch({
-      type: "data/deleteFromCache",
-      actionId: cacheKey,
-    })
-    delete newState[cacheKey]
-  } else {
-    // We still have child items so we will just delete the deleted flag in case we were called during grace deletion period
-    log.store(
-      "cacheRemove",
-      `the cache with hash ${cacheKey} is still/again in use by ${childQueries.length} queries`,
-    )
-    delete newState[cacheKey].deleted
+  const cacheEntry = state[cacheKey]
+  const queries = action.storeLookup?.queries ?? {}
+
+  if (!cacheEntry) {
+    return state
+  }
+
+  // Grace-period timeout: cacheAdd clears `deleted` when the same parent is requested again.
+  const isGraceEviction = cacheEntry.deleted === true
+
+  if (!isGraceEviction) {
+    const childCount = countChildQueriesForCacheKey(queries, cacheKey)
+    if (childCount > 0) {
+      const updated = { ...state[cacheKey] }
+      delete updated.deleted
+      action.actionResult.cacheRemoveCancelled = { cacheKey, childCount }
+
+      return { ...state, [cacheKey]: updated }
+    }
+  }
+
+  const uuids = cacheEntry.uuids ?? []
+  if (uuids.length > 0) {
+    action.actionResult.cacheEviction = { cacheKey, uuids }
   }
 
+  const newState = { ...state }
+  delete newState[cacheKey]
   return newState
 }
 
 const cacheChildRemove = (state, action) => {
-  const newState = structuredClone(state)
   const { actionId } = action.payload
   if (!actionId) return state
 
-  const affectedCacheQuery = getAffectedCacheQuery(state, actionId)
-  if (!affectedCacheQuery) {
+  const removedQuery = action.storeLookup?.queries?.[actionId]
+  const cacheRef = getCacheEntryForRemovedQuery(state, removedQuery)
+  if (!cacheRef) {
     return state
   }
-  const childQueries = getChildQueries(affectedCacheQuery.cacheKey)
-  if (childQueries.length === 1) {
-    // if the action which is currently deleted is the last one needing this cache, we will give it a 2sek grace period before we remove the cache
-    newState[affectedCacheQuery.cacheKey].deleted = true
-    if (deleteTimeouts[affectedCacheQuery.cacheKey]) {
-      clearTimeout(deleteTimeouts[affectedCacheQuery.cacheKey])
-      delete deleteTimeouts[affectedCacheQuery.cacheKey]
+
+  const { cacheKey } = cacheRef
+  const queries = action.storeLookup?.queries ?? {}
+  const childCount = countChildQueriesForCacheKey(queries, cacheKey)
+
+  if (childCount === 1) {
+    // if the action which is currently deleted is the last one needing this cache, we will give it a grace period before we remove the cache
+    action.actionResult.cacheGraceEviction = { cacheKey, actionId }
+
+    return {
+      ...state,
+      [cacheKey]: { ...state[cacheKey], deleted: true },
     }
-    deleteTimeouts[affectedCacheQuery.cacheKey] = setTimeout(() => {
-      $store.dispatch({
-        type: "queriesCache/remove",
-        payload: { cacheKey: affectedCacheQuery.cacheKey, actionId },
-      })
-    }, 500)
   }
-  delete cacheMap[actionId]
-  return newState
+
+  return state
 }
+
 export { cacheAdd, cacheCheck, cacheChildRemove, cacheRemove }