@raclettejs/core 0.1.37 → 0.1.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raclettejs/core",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "description": "racletteJS core package",
   "repository": "https://gitlab.com/raclettejs/core",
   "author": "Pacifico Digital Explorations GmbH <info@raclettejs.com>",
@@ -83,7 +83,7 @@
     "@emnapi/core": "1.9.2",
     "@emnapi/runtime": "1.9.2",
     "@eslint/js": "9.35.0",
-    "@raclettejs/types": "0.1.37",
+    "@raclettejs/types": "0.1.39",
     "@types/fs-extra": "11.0.4",
     "@types/js-yaml": "4.0.9",
     "@types/node": "25.5.0",

package/services/backend/package.json

@@ -13,7 +13,7 @@
     "build": "tsc --project tsconfig.build.json || true",
     "postbuild": "yarn run build:alias && yarn run build:assets",
     "build:alias": "tsc-alias -p tsconfig.build.json",
-    "build:assets:src": "copyfiles -u 1 'src/**/*.{json,js,yml,yaml,env*}' dist",
+    "build:assets:src": "copyfiles -u 1 'src/**/*.{init,json,js,yml,yaml,env*}' dist",
     "build:assets:root": "copyfiles -u 0 'raclette.config.js' dist",
     "build:assets": "npm run build:assets:src && npm run build:assets:root",
     "lint": "eslint .",

package/services/frontend/src/core/lib/scheduleTask.ts

@@ -0,0 +1,35 @@
+type IdleDeadline = {
+  didTimeout: boolean
+  timeRemaining: () => number
+}
+
+/**
+ * Run work after the next paint so timer handlers stay lightweight.
+ */
+export function scheduleAfterPaint(callback: () => void): void {
+  if (typeof requestAnimationFrame === "function") {
+    requestAnimationFrame(() => {
+      requestAnimationFrame(callback)
+    })
+    return
+  }
+
+  setTimeout(callback, 0)
+}
+
+/**
+ * Run non-urgent work during idle time (falls back to a macrotask).
+ */
+export function scheduleIdleWork(
+  callback: () => void,
+  options?: { timeout?: number },
+): void {
+  const timeout = options?.timeout ?? 2000
+
+  if (typeof requestIdleCallback === "function") {
+    requestIdleCallback((_deadline: IdleDeadline) => callback(), { timeout })
+    return
+  }
+
+  setTimeout(callback, 0)
+}

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

@@ -41,7 +41,10 @@ import {
 } from "./reducers/compositions"
 import backendReducers from "./reducers/backend"
 import { queriesEffects, queriesReducers } from "./reducers/queries"
-import { queriesCacheReducers } from "./reducers/queriesCache"
+import {
+  queriesCacheEffects,
+  queriesCacheReducers,
+} from "./reducers/queriesCache"
 import log from "@racletteCore/lib/logger"
 import type { RacletteStore, StoreHelperGetState } from "@racletteCore"
 
@@ -179,6 +182,7 @@ const registerStoreEffects = (store) => {
   compositionsEffects(store).forEach((effect) => effects.push(effect))
   interactionLinksEffects(store).forEach((effect) => effects.push(effect))
   queriesEffects(store).forEach((effect) => effects.push(effect))
+  queriesCacheEffects(store).forEach((effect) => effects.push(effect))
 
   effects.forEach((effect) => store.effect(effect))
 }

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

@@ -30,10 +30,6 @@ const compositionsSet = (state, action) => {
 }
 
 /* update page */
-const compositionsUpdate = (state, action) => {
-  console.warn("Implement: compositionsUpdate()")
-
-  return state
-}
+const compositionsUpdate = (state, action) => state
 
 export { addCompositionSlot, compositionsUpdate, projectInit, compositionsSet }

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

@@ -8,14 +8,14 @@ import {
   handleParentChildCountChange,
   handleDataIdPrefixing,
 } from "@racletteCore/lib/dataHelper"
-import { mergeDeepRight, clone, difference } from "ramda"
+import { mergeDeepRight, clone, difference, equals } from "ramda"
 import { v4 as uuidv4 } from "uuid"
 import * as dbItems from "./dbItems/index"
 
 const addDataToDataStore = (state, action, remote = false) => {
   const { result, actionIdentifier } = action.payload
   const { actionId, cacheKey } = actionIdentifier
-  const newState = structuredClone(state)
+  const newState = { ...state }
 
   result.forEach((_item) => {
     const item = structuredClone(_item)
@@ -28,20 +28,25 @@ const addDataToDataStore = (state, action, remote = false) => {
     )
     if (!state[item._id] || remote) {
       // if the item is completely new to the cache, or from a remote query we'll just add it
-      return (newState[item._id] = item)
+      newState[item._id] = item
+      return
     }
-    if (state[item._id]) {
-      if (!item._updatedAt && !state[item._id]._updatedAt) {
-        newState[item._id] = item
-      }
-      if (
-        item._updatedAt &&
-        state[item._id]._updatedAt &&
-        new Date(item._updatedAt) > new Date(state[item._id]._updatedAt)
-      ) {
-        newState[item._id] = item
-      }
-      newState[item._id].__requestedFor = item.__requestedFor
+    const existing = state[item._id]
+    if (!item._updatedAt && !existing._updatedAt) {
+      newState[item._id] = item
+      return
+    }
+    if (
+      item._updatedAt &&
+      existing._updatedAt &&
+      new Date(item._updatedAt) > new Date(existing._updatedAt)
+    ) {
+      newState[item._id] = item
+      return
+    }
+    newState[item._id] = {
+      ...existing,
+      __requestedFor: item.__requestedFor,
     }
   })
 
@@ -59,11 +64,7 @@ const addDataToDataStore = (state, action, remote = false) => {
  */
 const applyItemTemplate = (item, type) => {
   // TODO add dynamic plugin datatype schema retrieval here
-  let itemTemplate = dbItems[type]
-  if (!itemTemplate) {
-    console.warn(`no dbItem template for ${type} found`)
-  }
-  itemTemplate = dbItems.defaultItem(type, item)
+  const itemTemplate = dbItems.defaultItem(type, item)
 
   return itemTemplate
 }
@@ -118,26 +119,23 @@ const handleRequestActionIdRegistry = (
  * we currently have in our dataStore.
  * */
 const updateDataCache = (oldCache, newItems) => {
-  const newCache = structuredClone(oldCache)
+  const newCache = { ...oldCache }
 
   newItems.forEach((item) => {
     const oldItem = oldCache[item._id]
 
     // Tickets will just get updated if they have already been in the data Store due to a query
-    if (oldItem) {
-      newCache[item._id] = item
-    }
-    // apply the requestAction registry handler
-    if (newCache[item._id]) {
-      newCache[item._id].__requestedFor = handleRequestActionIdRegistry(
-        newCache[item._id],
-        oldItem,
-      )
-    }
-    // we will always delete the offline flag as this function will only be called by the dataRead which retrieves synced backend items
-    if (newCache[item._id]) {
-      delete newCache[item._id]._offline
+    if (!oldItem) {
+      return
     }
+
+    const updatedItem = { ...item }
+    updatedItem.__requestedFor = handleRequestActionIdRegistry(
+      updatedItem,
+      oldItem,
+    )
+    delete updatedItem._offline
+    newCache[item._id] = updatedItem
   })
 
   return newCache
@@ -197,8 +195,6 @@ const dataRead = (state, action) => {
     return state
   }
   if (!Array.isArray(payload)) {
-    console.error("data push needs to be an array!")
-
     return state
   }
 
@@ -324,10 +320,7 @@ const dataUpdate = (state, action) => {
   } else {
     item._source = mergeDeepRight(item._source, payload)
   }
-  if (
-    payload.tags &&
-    clone(payload.tags) !== clone(oldItem._source.tags || [])
-  ) {
+  if (payload.tags && !equals(payload.tags, oldItem._source.tags || [])) {
     // we have a change in tags, so let's find out what happened and change the childCount values for the tags accordingly
     const tagsAdded = difference(payload.tags, oldItem._source.tags || [])
     const tagsRemoved = difference(oldItem._source.tags || [], payload.tags)
@@ -438,33 +431,76 @@ const dataDelete = (state, action) => {
  *   @param {String} action.actionId - The Id of the query which requested the items
  * @returns {Object} - Returns the new state after removing the data from the cache.
  */
+const removeRequestedForFromItem = (dataItems, uuid, actionId) => {
+  if (!dataItems[uuid]) {
+    return
+  }
+  if (!dataItems[uuid].__requestedFor) {
+    delete dataItems[uuid]
+    return
+  }
+  if (dataItems[uuid].__requestedFor[actionId]) {
+    delete dataItems[uuid].__requestedFor[actionId]
+  }
+  if (!Object.keys(dataItems[uuid].__requestedFor).length) {
+    delete dataItems[uuid]
+  }
+}
+
 const deleteFromCache = (state, action) => {
   const { payload, actionId } = action
-  const dataItems = clone(state)
 
-  if (actionId) {
-    const iterateItems =
-      payload?.uuids && payload?.uuids?.length
-        ? payload?.uuids
-        : Object.keys(dataItems)
-    if (iterateItems.length) {
-      iterateItems.forEach((uuid) => {
-        if (!dataItems[uuid]) {
-          return
-        }
-        if (!dataItems[uuid].__requestedFor) {
-          delete dataItems[uuid]
-        }
-        // remove the indicator that this item was requested for the query in deletion process
-        if (dataItems[uuid].__requestedFor[actionId]) {
-          delete dataItems[uuid].__requestedFor[actionId]
-        }
-        // if item has no other requesters (i.e also not the global requestor) we can delete the item from the store as it is not needed anymore
-        if (!Object.keys(dataItems[uuid].__requestedFor).length) {
-          delete dataItems[uuid]
-        }
-      })
+  if (!actionId) {
+    return state
+  }
+
+  const uuids = payload?.uuids?.length ? payload.uuids : null
+
+  if (uuids) {
+    const needsUpdate = uuids.some((uuid) => {
+      const item = state[uuid]
+      if (!item) {
+        return false
+      }
+      if (!item.__requestedFor) {
+        return true
+      }
+      return Boolean(item.__requestedFor[actionId])
+    })
+
+    if (!needsUpdate) {
+      return state
     }
+
+    const dataItems = { ...state }
+    uuids.forEach((uuid) => {
+      if (!dataItems[uuid]) {
+        return
+      }
+      if (!dataItems[uuid].__requestedFor) {
+        delete dataItems[uuid]
+        return
+      }
+      if (!dataItems[uuid].__requestedFor[actionId]) {
+        return
+      }
+      const updatedItem = clone(dataItems[uuid])
+      delete updatedItem.__requestedFor[actionId]
+      if (!Object.keys(updatedItem.__requestedFor).length) {
+        delete dataItems[uuid]
+      } else {
+        dataItems[uuid] = updatedItem
+      }
+    })
+    return dataItems
+  }
+
+  const dataItems = clone(state)
+  const iterateItems = Object.keys(dataItems)
+  if (iterateItems.length) {
+    iterateItems.forEach((uuid) => {
+      removeRequestedForFromItem(dataItems, uuid, actionId)
+    })
   }
 
   return dataItems
@@ -493,13 +529,13 @@ const dataMove = (state, action) => {
   }
 
   if (!item) {
-    console.error("item moved which is not in dataStore!")
+    return state
   }
   if (!item._meta) {
     item._meta = {}
   }
   if (!item?._meta?.path) {
-    console.error("item has no path!")
+    return state
   }
   const updateObj = {}
 

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

@@ -37,6 +37,29 @@ interface ActionResult {
     deleted: any[]
     resolved: any[]
   }
+  dataCacheCleanup?: {
+    actionId: string
+    uuids: string[]
+  }
+  queryDeleted?: {
+    actionId: string
+    query: Record<string, unknown>
+  }
+  cacheEviction?: {
+    cacheKey: string
+    uuids: string[]
+  }
+  cacheGraceEviction?: {
+    cacheKey: string
+    actionId: string
+  }
+  cacheGraceCancel?: {
+    cacheKey: string
+  }
+  cacheRemoveCancelled?: {
+    cacheKey: string
+    childCount: number
+  }
 }
 const decorateAction = (reducer) => (state, action) => {
   action.storeLookup = {

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

@@ -3,17 +3,18 @@
  */
 import { applicationState } from "../../state"
 import { clone, mergeDeepRight } from "ramda"
-import { $store } from "@racletteCore"
+
 /**
  * add notifcation
  */
 const notificationsAdd = (state, action) => {
   const items = clone(state.items)
   const notificationTime = new Date()
-  const notificationEntry = action.payload
-
-  notificationEntry.time = notificationTime
-  notificationEntry.state = "unread"
+  const notificationEntry = {
+    ...action.payload,
+    time: notificationTime,
+    state: "unread",
+  }
   // as we just want updates pushed to the notification que per item and editor each 5min
   const notificationTimeThreshold = 1000 * 60 * 5
   const notificationKeyTime = new Date(
@@ -47,16 +48,11 @@ const notificationsMarkAllAsSeen = (state, action) => {
       item.state = "seen"
     }
   })
-  $store.dispatch({
-    type: "notifications/update",
-    payload: {
-      unreadCount: 0,
-    },
-  })
 
   return {
     ...state,
     items,
+    unreadCount: 0,
   }
 }
 
@@ -71,16 +67,11 @@ const notificationsMarkAllAsRead = (state, action) => {
       item.state = "read"
     }
   })
-  $store.dispatch({
-    type: "notifications/update",
-    payload: {
-      unreadCount: 0,
-    },
-  })
 
   return {
     ...state,
     items,
+    unreadCount: 0,
   }
 }
 
@@ -88,23 +79,20 @@ const notificationsMarkAllAsRead = (state, action) => {
  * mark notification as read
  */
 const notificationsMarkAsRead = (state, action) => {
-  const items = clone(state.items)
+  const queKey = action.payload.queKey
+  const item = state.items[queKey]
 
-  if (items[action.payload.queKey].state !== "read") {
-    items[action.payload.queKey].state = "read"
-    if (state.unreadCount > 0) {
-      $store.dispatch({
-        type: "notifications/update",
-        payload: {
-          unreadCount: state.unreadCount - 1,
-        },
-      })
-    }
+  if (!item || item.state === "read") {
+    return state
   }
 
   return {
     ...state,
-    items: items,
+    items: {
+      ...state.items,
+      [queKey]: { ...item, state: "read" },
+    },
+    unreadCount: state.unreadCount > 0 ? state.unreadCount - 1 : state.unreadCount,
   }
 }
 
@@ -112,21 +100,20 @@ const notificationsMarkAsRead = (state, action) => {
  * mark notifcation as unread
  */
 const notificationsMarkUnread = (state, action) => {
-  const items = clone(state.items)
+  const queKey = action.payload.queKey
+  const item = state.items[queKey]
 
-  if (items[action.payload.queKey].state !== "unread") {
-    items[action.payload.queKey].state = "unread"
-    $store.dispatch({
-      type: "notifications/update",
-      payload: {
-        unreadCount: state.unreadCount + 1,
-      },
-    })
+  if (!item || item.state === "unread") {
+    return state
   }
 
   return {
     ...state,
-    items: items,
+    items: {
+      ...state.items,
+      [queKey]: { ...item, state: "unread" },
+    },
+    unreadCount: state.unreadCount + 1,
   }
 }
 
@@ -135,15 +122,20 @@ const notificationsMarkUnread = (state, action) => {
  */
 const notificationsToggle = (state, action) => {
   if (action.payload.toggled === false && state.toggled === true) {
-    $store.dispatch({
-      type: "notifications/update",
-      payload: {
-        unreadCount: 0,
-      },
-    })
-    $store.dispatch({
-      type: "notifications/markAllAsSeen",
+    const items = clone(state.items)
+
+    Object.values(items).forEach((item) => {
+      if (item.state !== "read") {
+        item.state = "seen"
+      }
     })
+
+    return {
+      ...state,
+      ...action.payload,
+      items,
+      unreadCount: 0,
+    }
   }
 
   return {

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

@@ -1,7 +1,23 @@
 import { tap, distinctUntilChanged, ignoreElements } from "rxjs/operators"
 import { actions$, ofType } from "mini-rx-store"
 import { getData } from "@racletteCore/lib/data/dataApi"
-import log from "@racletteCore/lib/logger"
+import { scheduleIdleWork } from "@racletteCore/lib/scheduleTask"
+import { $eventbus } from "@racletteCore/main"
+
+const dispatchDataCacheCleanup = (store, cleanup) => {
+  if (!cleanup?.uuids?.length || !cleanup?.actionId) {
+    return
+  }
+
+  scheduleIdleWork(() => {
+    store.dispatch({
+      type: "data/deleteFromCache",
+      payload: { uuids: cleanup.uuids },
+      actionId: cleanup.actionId,
+    })
+  })
+}
+
 const queriesEffects = (store) => {
   const queriesAddExecute = actions$.pipe(
     ofType("queries/add/execute"),
@@ -22,6 +38,7 @@ const queriesEffects = (store) => {
     ),
     ignoreElements(),
   )
+
   const queriesExecute = actions$.pipe(
     ofType("queries/execute"),
     distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
@@ -35,6 +52,7 @@ const queriesEffects = (store) => {
     }),
     ignoreElements(),
   )
+
   const queryiesSetCacheKey = actions$.pipe(
     ofType("queries/setCacheKey"),
     distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
@@ -54,7 +72,42 @@ const queriesEffects = (store) => {
     }),
     ignoreElements(),
   )
-  return [queriesAddExecute, queriesExecute, queryiesSetCacheKey]
+
+  const queriesUpdateItemsCleanup = actions$.pipe(
+    ofType("queries/updateItems"),
+    distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
+
+    tap((action) => {
+      dispatchDataCacheCleanup(store, action.actionResult?.dataCacheCleanup)
+    }),
+    ignoreElements(),
+  )
+
+  const queriesRemoveSideEffects = actions$.pipe(
+    ofType("queries/remove"),
+    distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
+
+    tap((action) => {
+      dispatchDataCacheCleanup(store, action.actionResult?.dataCacheCleanup)
+
+      const deleted = action.actionResult?.queryDeleted as
+        | { actionId: string; query: Record<string, unknown> }
+        | undefined
+
+      if (deleted?.actionId) {
+        $eventbus.emit("query_deleted_" + deleted.actionId, deleted.query)
+      }
+    }),
+    ignoreElements(),
+  )
+
+  return [
+    queriesAddExecute,
+    queriesExecute,
+    queryiesSetCacheKey,
+    queriesUpdateItemsCleanup,
+    queriesRemoveSideEffects,
+  ]
 }
 
 export default queriesEffects