@raclettejs/core 0.0.1

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

@@ -0,0 +1,64 @@
+/**
+ * Build meta reducers for store configuration
+ */
+/**
+ * decorate action object
+ * with the store lookup and a predefined actionResult object for reliable result handling in effects
+ */
+interface MoveData {
+  item: {}
+  from: string
+  to: string
+}
+interface ActionResult {
+  moved: MoveData | {}
+  added: any[]
+  created: any[]
+  updated: {
+    item?: any
+    itemBefore?: any
+    items?: {
+      [key: string]: any // Current state of items, stored by their IDs
+    }
+    itemsBefore?: {
+      [key: string]: any // Previous state of items, stored by their IDs
+    }
+  }
+  deleted: {
+    soft?: {
+      [key: string]: any
+    }
+    hard?: {
+      [key: string]: any
+    }
+  }
+  relationships: {
+    created: any[]
+    deleted: any[]
+    resolved: any[]
+  }
+}
+const decorateAction = (reducer) => (state, action) => {
+  action.storeLookup = {
+    ...state,
+  }
+  const actionResult: ActionResult = {
+    moved: [],
+    added: [],
+    created: [],
+    updated: { itemsBefore: {}, items: {} },
+    deleted: { soft: {}, hard: {} },
+    relationships: {
+      created: [],
+      deleted: [],
+      resolved: [],
+    },
+  }
+
+  action.actionResult = actionResult
+
+  return reducer(state, action)
+}
+const metaReducers = [decorateAction]
+
+export default metaReducers

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

@@ -0,0 +1,20 @@
+/**
+ * notification reducer
+ */
+import * as reducers from "./reducers"
+import reducerFromMap from "@racletteCore/lib/reducerFromMap"
+import { applicationState } from "@racletteCore/store/state"
+
+const reducerMap = {
+  init: () => applicationState.notifications,
+  "notifications/add": reducers.notificationsAdd,
+  "notifications/clear": reducers.notificationsClear,
+  "notifications/markAllAsSeen": reducers.notificationsMarkAllAsSeen,
+  "notifications/markAllAsRead": reducers.notificationsMarkAllAsRead,
+  "notifications/markAsRead": reducers.notificationsMarkAsRead,
+  "notifications/markUnread": reducers.notificationsMarkUnread,
+  "notifications/toggle": reducers.notificationsToggle,
+  "notifications/update": reducers.notificationsUpdate,
+}
+
+export default reducerFromMap(reducerMap)

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

@@ -0,0 +1,170 @@
+/**
+ * notifcation reducers
+ */
+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"
+  // 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(
+    Math.round(notificationTime.getTime() / notificationTimeThreshold) *
+      notificationTimeThreshold,
+  )
+  const notificationKey = `${notificationTime.getMonth()}-${notificationTime.getDay()}-${notificationTime.getHours()}-${notificationKeyTime.getMinutes()}-${notificationEntry.event}-${notificationEntry.updatedBy}-${notificationEntry.item ? notificationEntry.item : 0}`
+
+  items[notificationKey] = notificationEntry
+
+  return {
+    ...state,
+    items,
+    unreadCount: state.unreadCount + 1,
+  }
+}
+
+/**
+ * clear notifications
+ */
+const notificationsClear = (state, action) => applicationState.notifications
+
+/**
+ * mark all notifcations as seen
+ */
+const notificationsMarkAllAsSeen = (state, action) => {
+  const items = clone(state.items)
+
+  Object.values(items).forEach((item) => {
+    if (item.state !== "read") {
+      item.state = "seen"
+    }
+  })
+  $store.dispatch({
+    type: "notifications/update",
+    payload: {
+      unreadCount: 0,
+    },
+  })
+
+  return {
+    ...state,
+    items,
+  }
+}
+
+/**
+ * mark all notifactions as read
+ */
+const notificationsMarkAllAsRead = (state, action) => {
+  const items = clone(state.items)
+
+  Object.values(items).forEach((item) => {
+    if (item.state === "unread") {
+      item.state = "read"
+    }
+  })
+  $store.dispatch({
+    type: "notifications/update",
+    payload: {
+      unreadCount: 0,
+    },
+  })
+
+  return {
+    ...state,
+    items,
+  }
+}
+
+/**
+ * mark notification as read
+ */
+const notificationsMarkAsRead = (state, action) => {
+  const items = clone(state.items)
+
+  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,
+        },
+      })
+    }
+  }
+
+  return {
+    ...state,
+    items: items,
+  }
+}
+
+/**
+ * mark notifcation as unread
+ */
+const notificationsMarkUnread = (state, action) => {
+  const items = clone(state.items)
+
+  if (items[action.payload.queKey].state !== "unread") {
+    items[action.payload.queKey].state = "unread"
+    $store.dispatch({
+      type: "notifications/update",
+      payload: {
+        unreadCount: state.unreadCount + 1,
+      },
+    })
+  }
+
+  return {
+    ...state,
+    items: items,
+  }
+}
+
+/**
+ * toggle notifications
+ */
+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",
+    })
+  }
+
+  return {
+    ...state,
+    ...action.payload,
+  }
+}
+
+/**
+ * update notifications
+ */
+const notificationsUpdate = (state, action) =>
+  mergeDeepRight(state, action.payload)
+
+export {
+  notificationsAdd,
+  notificationsClear,
+  notificationsMarkAllAsSeen,
+  notificationsMarkAllAsRead,
+  notificationsMarkAsRead,
+  notificationsMarkUnread,
+  notificationsToggle,
+  notificationsUpdate,
+}

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

@@ -0,0 +1,129 @@
+/**
+ * project reducer
+ */
+import { applicationState } from "../../state"
+import { clone, mergeDeepRight } from "ramda"
+import reducerFromMap from "@racletteCore/lib/reducerFromMap"
+const removeEmptyAttributes = (
+  obj: Record<string, any>,
+): Record<string, any> => {
+  // Create a new object to store non-empty attributes
+  const result: Record<string, any> = {}
+
+  // Check each key in the object
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const value = obj[key]
+
+      // Check if value is null or undefined
+      if (value === null || value === undefined) {
+        continue
+      }
+
+      // Check if value is an empty string
+      if (typeof value === "string" && value.trim() === "") {
+        continue
+      }
+
+      // Check if value is an array and is empty
+      if (Array.isArray(value) && value.length === 0) {
+        continue
+      }
+
+      // Check if value is an object
+      if (typeof value === "object" && !Array.isArray(value)) {
+        // Recursively remove empty attributes from nested objects
+        const cleanedObject = removeEmptyAttributes(value)
+
+        // Only include the object if it has keys after cleaning
+        if (Object.keys(cleanedObject).length > 0) {
+          result[key] = cleanedObject
+        }
+      } else {
+        // Keep the attribute if it passed all the emptiness checks
+        result[key] = value
+      }
+    }
+  }
+
+  return result
+}
+// map instead of switch statement
+const reducerMap = {
+  init: () => applicationState.project,
+  projectInit: (state, action) => {
+    const newState = clone(state)
+
+    delete newState.queryModifier
+
+    return newState
+  },
+  "project/updateConfig": (state, action) => {
+    const config = action.payload
+    const configType = action.configType
+
+    if (!config || !configType) {
+      return state
+    }
+
+    if (state._id !== config._project) {
+      return state
+    }
+    action.actionResult.updated.itemsBefore[config._id] = clone(
+      state.configs[configType],
+    )
+    const newState = clone(state)
+
+    newState.configs[configType] = config
+    action.actionResult.updated.items[config._id] = config
+
+    return newState
+  },
+  "project/addConfig": (state, action) => {
+    const config = action.payload
+
+    if (!config) {
+      return state
+    }
+
+    if (state._id !== config._project) {
+      return state
+    }
+    const newState = {
+      ...state,
+      configs: {
+        ...(state.configs || {}),
+        [config._type]: config._source,
+      },
+    }
+
+    // Perform deep merge of all configs
+    newState.config = Object.values(newState.configs).reduce(
+      (mergedConfig, configObj) =>
+        mergeDeepRight(mergedConfig, removeEmptyAttributes(configObj.config)),
+
+      {},
+    )
+
+    // Update action result
+    action.actionResult.added.push(config)
+
+    return newState
+  },
+  "project/addQueryModifier": (state, action) => ({
+    ...state,
+    ...{ queryModifier: action.payload },
+  }),
+  "project/setId": (state, action) => {
+    const newState = clone(state)
+
+    newState._id = action.payload
+
+    return newState
+  },
+  "project/set": (state, action) => action.payload,
+}
+
+const projectReducers = reducerFromMap(reducerMap)
+
+export { projectReducers }

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

@@ -0,0 +1,45 @@
+/**
+ * project reducer
+ */
+import { applicationState } from "../../state"
+import { clone } from "ramda"
+import reducerFromMap from "@racletteCore/lib/reducerFromMap"
+
+const addProjectToList = (projects, project) => {
+  projects[project._id] = project._source
+}
+// map instead of switch statement
+const reducerMap = {
+  init: () => applicationState.projects,
+  "projects/add": (state, action) => {
+    if (!action.payload) {
+      return
+    }
+    const newState = clone(state)
+
+    if (Array.isArray(action.payload)) {
+      action.actionResult.added = action.payload
+      action.payload.forEach((project) => addProjectToList(newState, project))
+    } else {
+      action.actionResult.added.push(action.payload)
+      addProjectToList(newState, action.payload)
+    }
+
+    return newState
+  },
+  "projects/update": (state, action) => {
+    const { projectId, payload } = action
+    const newState = clone(state)
+
+    if (!projectId) {
+      return state
+    }
+    newState[projectId] = payload
+
+    return newState
+  },
+}
+
+const projectsReducers = reducerFromMap(reducerMap)
+
+export default projectsReducers

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

@@ -0,0 +1,40 @@
+import { tap, distinctUntilChanged, ignoreElements } from "rxjs/operators"
+import { actions$, ofType } from "mini-rx-store"
+import { getData } from "@racletteCore/lib/data/dataApi"
+const queriesEffects = (store) => {
+  const queriesAddExecute = actions$.pipe(
+    ofType("queries/add/execute"),
+    distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
+
+    tap((action) =>
+      action.actionResult.added?.forEach((query) =>
+        store.dispatch({
+          type: "queries/execute",
+          payload: {
+            actionId: query.actionId,
+            reset: true,
+            target: query.target,
+            params: query.params,
+          },
+        }),
+      ),
+    ),
+    ignoreElements(),
+  )
+  const queriesExecute = actions$.pipe(
+    ofType("queries/execute"),
+    distinctUntilChanged((prev, curr) => !store.hasChanges(prev, curr)),
+
+    tap((action) => {
+      if (Object.keys(action.actionResult.updated.items).length) {
+        Object.values(action.actionResult.updated.items).forEach((query) => {
+          getData(query.actionId, query.target, query.params || false)
+        })
+      }
+    }),
+    ignoreElements(),
+  )
+  return [queriesAddExecute, queriesExecute]
+}
+
+export default queriesEffects

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

@@ -0,0 +1,22 @@
+/**
+ * queries reducer
+ */
+import { applicationState } from "@racletteCore/store/state"
+import * as reducers from "./reducers"
+import reducerFromMap from "@racletteCore/lib/reducerFromMap"
+import queriesEffects from "./effects"
+
+const reducerMap = {
+  init: () => applicationState.queries,
+  "queries/execute": reducers.queriesExecute,
+  "queries/add": reducers.queriesAdd,
+  "queries/add/execute": reducers.queriesAdd,
+  "queries/remove": reducers.queriesRemove,
+  "queries/updateItems": reducers.updateQueryItems,
+  "queries/update": reducers.updateQuery,
+  "queries/update/loading": reducers.queriesUpdateLoading,
+}
+
+const queriesReducers = reducerFromMap(reducerMap)
+
+export { queriesEffects, queriesReducers }