@raclettejs/core 0.0.1

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

@@ -0,0 +1,225 @@
+/**
+ * queries reducers
+ */
+
+import { fixQueryParamTypes } from "@racletteCore/lib/dataHelper"
+import { difference, mergeDeepRight, filter } from "ramda"
+import type { CustomStoreActionParams } from "@racletteCore/types"
+import { $eventbus, $store } from "@racletteCore/main"
+export type Query = {
+  target: string
+  actionId: string
+  params: Record<string, any>
+  loading?: boolean
+  backend?: Record<string, any>
+  uuids?: Array<string>
+}
+
+const updateQueryItems = (state, action) => {
+  const { items, actionId } = action.payload
+  if (!actionId || !state[actionId]) {
+    return state
+  }
+  const queries = structuredClone(state)
+  const query = queries[actionId]
+  if (items) {
+    const uuids = Object.values(items).map((item) => item._id)
+    let dataItemsToRemove = []
+
+    if (query.uuids) {
+      dataItemsToRemove = difference(query.uuids, uuids)
+    }
+
+    query.loading = false
+    query.uuids = uuids
+    if (dataItemsToRemove.length > 0) {
+      $store.dispatch({
+        type: "data/deleteFromCache",
+        payload: dataItemsToRemove,
+        actionId: actionId,
+      })
+    }
+  }
+
+  return queries
+}
+
+const updateQuery = (state, action) => {
+  const payload = action.payload
+  const actionId = payload.actionId
+  if (!actionId || !state[actionId]) {
+    return state
+  }
+
+  let queries = structuredClone(state)
+  const query = queries[actionId]
+  if (payload.target) {
+    query.target = payload.target
+  }
+  if (payload.pageItems) {
+    const uuids = []
+    const results = payload.pageItems || null
+
+    if (results) {
+      results.forEach((item) => uuids.push(item._id))
+    }
+
+    if (query.uuids && query.uuids.length > 0) {
+      query.uuids = query.uuids.concat(uuids)
+    } else {
+      query.uuids = uuids
+    }
+  }
+  if (payload.hasOwnProperty("uuids")) {
+    query.uuids = payload.uuids
+  }
+  if (payload.hasOwnProperty("loading")) {
+    query.loading = payload.loading
+  }
+  if (payload.hasOwnProperty("params")) {
+    if (payload.reset) {
+      query.params = payload.params
+    } else {
+      query.params = mergeDeepRight(query.params || {}, payload.params)
+    }
+  }
+
+  if (payload.backend) {
+    if (payload.reset) {
+      query.backend = payload.backend
+    } else {
+      query.backend = mergeDeepRight(query.backend || {}, payload.backend)
+    }
+  }
+  query.params = fixQueryParamTypes(query.params)
+  if (query.backend) {
+    query.backend = fixQueryParamTypes(query.backend)
+  }
+
+  return queries
+}
+
+const queriesUpdateLoading = (state, action) => {
+  const payload = action.payload
+  const actionId = payload.actionId
+  if (!actionId || !state[actionId]) {
+    return state
+  }
+  const queries = structuredClone(state)
+  const query = queries[actionId]
+  if (payload.hasOwnProperty("loading")) {
+    query.loading = payload.loading
+  }
+  return queries
+}
+/**
+ * execute queries
+ */
+const queriesExecute = (state, action) => {
+  if (Object.keys(state).length === 0) {
+    return state
+  }
+  const { target, params, actionId, reset, type } = structuredClone(
+    action.payload,
+  )
+  const isResetQuery = reset || params?.reset
+  const queries = structuredClone(state)
+
+  if (actionId && queries[actionId]) {
+    const query = queries[actionId]
+
+    query.loading = true
+    action.actionResult.updated.itemsBefore[actionId] = state[actionId]
+
+    if (params && !isResetQuery) {
+      query.params = { ...query.params, ...params }
+    }
+    if (isResetQuery) {
+      query.params = params
+      delete query.params.reset
+      delete query.reset
+    }
+    if (target) {
+      query.target = target
+    }
+    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 queries
+}
+/**
+ * add queries
+ */
+const queriesAdd = (state, action) => {
+  if (!action.payload.actionId) {
+    return state
+  }
+  const payload = structuredClone(action.payload)
+  const params: CustomStoreActionParams = payload.params || {}
+  const actionId = payload.actionId
+  const target = payload.target
+
+  const query: Query = {
+    target,
+    params,
+    actionId,
+  }
+
+  action.actionResult.added.push(query)
+  const queries = structuredClone(state)
+  queries[actionId] = query
+
+  return queries
+}
+
+/**
+ * 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: query.uuids,
+        actionId: actionId,
+      })
+    }
+
+    $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]
+  }
+
+  return queries || {}
+}
+
+export {
+  queriesExecute,
+  queriesAdd,
+  queriesRemove,
+  updateQueryItems,
+  updateQuery,
+  queriesUpdateLoading,
+}

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

@@ -0,0 +1,15 @@
+import reducerFromMap from "@racletteCore/lib/reducerFromMap"
+import { applicationState } from "@racletteCore/store/state"
+import * as reducers from "./reducers"
+
+const reducerMap = {
+  init: () => applicationState.queriesCache || {},
+  "queriesCache/add": reducers.cacheAdd,
+  "queriesCache/remove": reducers.cacheRemove,
+  "queries/updateItems": reducers.cacheCheck,
+  "queries/remove": reducers.cacheChildRemove,
+}
+
+const queriesCacheReducers = reducerFromMap(reducerMap)
+
+export { queriesCacheReducers }

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

@@ -0,0 +1,68 @@
+import createStableHash from "@racletteCore/lib/createStableHash"
+import { $store } from "@racletteCore"
+import log from "@racletteCore/lib/logger"
+
+const isParentResultFresh = (cacheKey: string): boolean => {
+  const queriesState = $store.getState("queriesCache")
+  const currentTimeStamp = new Date().getTime()
+  const parentQuery = queriesState[cacheKey]
+
+  if (
+    !parentQuery.lastFetched ||
+    !parentQuery.uuids ||
+    parentQuery.hasOwnProperty("loading") === false ||
+    parentQuery.loading === true
+  ) {
+    log.store(
+      "queryCacheHelper",
+      `the cache with hash ${cacheKey} has not been executed yet or is still fetching`,
+    )
+    return false
+  }
+
+  const isParentResultFresh = parentQuery.lastFetched + 1000 >= currentTimeStamp
+
+  log.store(
+    "queryCacheHelper",
+    `the cache with hash ${cacheKey} is ${isParentResultFresh ? "fresh" : "outdated"}`,
+  )
+
+  return isParentResultFresh
+}
+
+const getParentActionIdHash = (
+  target: string,
+  params: Record<string, any>,
+): string => {
+  return createStableHash({
+    target,
+    params,
+  })
+}
+
+const getCacheQueryAndHash = (
+  target: string,
+  params: Record<string, any>,
+): { query: Record<string, any> | undefined; hash: string } => {
+  const hash = getParentActionIdHash(target, params)
+  const state = $store.getState("queriesCache")
+  return {
+    query: state[hash],
+    hash,
+  }
+}
+
+const hasCacheQuery = (
+  target: string,
+  params: Record<string, any>,
+): boolean => {
+  const cacheQuery = getCacheQueryAndHash(target, params).query
+  return !!cacheQuery
+}
+
+export {
+  getCacheQueryAndHash,
+  hasCacheQuery,
+  getParentActionIdHash,
+  isParentResultFresh,
+}

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

@@ -0,0 +1,137 @@
+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 => {
+  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
+}
+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
+    }
+  }
+
+  return newState
+}
+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)
+    }
+  }
+
+  return newState
+}
+const cacheRemove = (state, action) => {
+  const newState = structuredClone(state)
+  const { cacheKey, actionId } = action.payload
+  const cache = state[cacheKey]
+
+  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",
+      payload: cache?.uuids || [],
+      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
+  }
+
+  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) {
+    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 3sek grace period before we remove the cache
+    newState[affectedCacheQuery.cacheKey].deleted = true
+    if (deleteTimeouts[affectedCacheQuery.cacheKey]) {
+      clearTimeout(deleteTimeouts[affectedCacheQuery.cacheKey])
+      delete deleteTimeouts[affectedCacheQuery.cacheKey]
+    }
+    deleteTimeouts[affectedCacheQuery.cacheKey] = setTimeout(() => {
+      $store.dispatch({
+        type: "queriesCache/remove",
+        payload: { cacheKey: affectedCacheQuery.cacheKey, actionId },
+      })
+    }, 1000)
+  }
+  delete cacheMap[actionId]
+  return newState
+}
+export { cacheAdd, cacheCheck, cacheChildRemove, cacheRemove }

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

@@ -0,0 +1,18 @@
+/**
+ * ui reducer
+ */
+import { applicationState } from "@racletteCore/store/state"
+import * as reducers from "./reducers"
+import reducerFromMap from "@racletteCore/lib/reducerFromMap"
+
+// map instead of switch statement
+const reducerMap = {
+  init: () => applicationState.ui,
+  projectInit: reducers.projectInit,
+  "ui/setCompositionAs": reducers.setCompositionAs,
+  "ui/unsetComposition": reducers.unsetComposition,
+  "ui/toggle": reducers.uiToggle,
+  "ui/update": reducers.uiUpdate,
+}
+
+export default reducerFromMap(reducerMap)

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

@@ -0,0 +1,66 @@
+import { applicationState } from "../../state"
+import { hasOwnProperty } from "@racletteCore/lib/dataHelper"
+import { clone } from "ramda"
+/**
+ * project init
+ */
+const projectInit = (state, action) => applicationState.ui
+
+const setCompositionAs = (
+  state,
+  action: {
+    payload: { slot: string; compositionId?: string }
+  },
+) => {
+  const { slot, compositionId } = action.payload
+  const newState = clone(state)
+
+  if (compositionId) {
+    newState[slot] = compositionId
+  }
+
+  return newState
+}
+
+const unsetComposition = (state, action) => {
+  const { slot } = action.payload
+
+  const newState = clone(state)
+  newState[slot] = null
+
+  return newState
+}
+
+/**
+ *  toggle ui
+ */
+const uiToggle = (state, action) => {
+  const uiState = {}
+
+  if (!action.payload.list) {
+    return state
+  }
+
+  action.payload.list.forEach((field) => {
+    if (hasOwnProperty(state, field)) {
+      if (state[field]) {
+        uiState[field] = false
+      }
+      if (!state[field]) {
+        uiState[field] = true
+      }
+      if (state[field] === true || state[field] === false) {
+        uiState[field] = !state[field]
+      }
+    }
+  })
+
+  return { ...state, ...uiState }
+}
+
+/**
+ *  update ui
+ */
+const uiUpdate = (state, action) => ({ ...state, ...action.payload })
+
+export { projectInit, uiToggle, uiUpdate, setCompositionAs, unsetComposition }

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

@@ -0,0 +1,37 @@
+import { clone } from "ramda"
+import { applicationState } from "../../state"
+import reducerFromMap from "@racletteCore/lib/reducerFromMap"
+
+/**
+ * set user
+ */
+const userSet = (state, action) => {
+  if (state?._id) {
+    return state
+  }
+  if (action?.payload?._id) {
+    return action.payload
+  }
+
+  return state
+}
+
+/**
+ * update user
+ */
+const userUpdate = (state, action) => {
+  const userState = clone(state)
+
+  return { ...userState, ...action.payload }
+}
+
+/**
+ * define map
+ */
+const reducerMap = {
+  init: () => applicationState.user,
+  "user/set": userSet,
+  "user/update": userUpdate,
+}
+
+export default reducerFromMap(reducerMap)

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

@@ -0,0 +1,28 @@
+import { applicationState } from "../../state"
+import * as reducers from "./reducers"
+import { tap, ignoreElements, distinctUntilChanged } from "rxjs/operators"
+import reducerFromMap from "@racletteCore/lib/reducerFromMap"
+import { actions$, ofType } from "mini-rx-store"
+
+const reducerMap = {
+  init: () => applicationState.widgets,
+  projectInit: reducers.projectInit,
+  "widgets/update": reducers.widgetsUpdate,
+  "widgets/add": reducers.widgetsAdd,
+  "widgets/setConfig": reducers.widgetsSetConfig,
+}
+
+const widgetEffects = (store) => {
+  const widgetAddEffects = actions$.pipe(
+    ofType("widgets/add"),
+
+    distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
+
+    ignoreElements(),
+  )
+
+  return [widgetAddEffects]
+}
+const widgetsReducers = reducerFromMap(reducerMap)
+
+export { widgetEffects, widgetsReducers }

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

@@ -0,0 +1,92 @@
+import { mergeDeepRight, clone } from "ramda"
+import { applicationState, storePatterns } from "@racletteCore/store/state"
+
+const cleanWidgetState = (widget) => {
+  const cleanWidget = clone(widget)
+
+  delete cleanWidget.type
+
+  return cleanWidget
+}
+
+/**
+ * project init
+ */
+const projectInit = (state, action) => applicationState.widgets
+
+/**
+ * set widget config
+ */
+const widgetsSetConfig = (state, action) => {
+  const newState = clone(state)
+
+  if (!action.uuid) {
+    return state
+  }
+  const widgetItem = mergeDeepRight(newState[action.uuid] || {}, action.payload)
+
+  widgetItem.config = mergeDeepRight(
+    action.payload?.config || {},
+    widgetItem.config || {},
+  )
+  newState[action.uuid] = cleanWidgetState(widgetItem)
+
+  return newState
+}
+
+/**
+ * update widget
+ */
+const widgetsUpdate = (state, action) => {
+  const newState = clone(state)
+
+  if (!action.uuid) {
+    return state
+  }
+  const { payload, override } = action
+
+  // merge given payload onto widget state
+  if (override) {
+    for (const [key, value] of Object.entries(payload)) {
+      newState[action.uuid][key] = value
+    }
+  } else {
+    newState[action.uuid] = mergeDeepRight(state[action.uuid], action.payload)
+  }
+  newState[action.uuid] = cleanWidgetState(newState[action.uuid])
+
+  return newState
+}
+
+/**
+ * add widget
+ */
+const widgetsAdd = (state, action) => {
+  const newWidgets = {}
+
+  if (action.payload.length === 0) {
+    return state
+  }
+  action.payload.forEach((widget) => {
+    if (widget.uuid && state[widget.uuid]) {
+      // if we are in widgets/add but the widget uuid already exists, we do
+      // nothing as updates shall be done in widgets/update
+      return state
+    }
+    // add page specific config to widget instance state
+    if (!newWidgets[widget.uuid]) {
+      newWidgets[widget.uuid] = cleanWidgetState(
+        mergeDeepRight(storePatterns.widget, widget),
+      )
+    }
+  })
+  return mergeDeepRight(state, newWidgets)
+}
+
+export {
+  widgetsUpdate,
+  widgetsAdd,
+  widgetsSetConfig,
+  cleanWidgetState,
+  projectInit,
+}