@raclettejs/core 0.1.18 → 0.1.20

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/workSession.service.ts

@@ -0,0 +1,351 @@
+import type {
+  WorkSessionCreate,
+  WorkSession as WorkSessionType,
+  WorkSessionUpdate,
+} from "./workSession.schema"
+import type {
+  FrontendPayload,
+  FrontendPayloadRequestData,
+} from "@c/payload/payloadTypes"
+import type { QueryOptions } from "@m/database/providers/mongodb/service"
+import { v4 as uuidv4, validate } from "uuid"
+import { createWorkSessionPayload } from "./helpers/payload"
+import type { Model } from "mongoose"
+import type { PluginFastifyInstance } from "types"
+import { mergeDeepRight } from "ramda"
+
+export type WorkSessionBody = Partial<Omit<WorkSessionType, "_id">> & {
+  _id?: string
+}
+
+// Using a class to preserve 'this' context
+export class WorkSessionService {
+  private workSessionModel: Model<WorkSessionType>
+
+  constructor(model: Model<WorkSessionType>) {
+    this.workSessionModel = model
+  }
+  /**
+   * Core function to create a new workSession (returns raw data)
+   */
+  async _createWorkSession(
+    fastify: PluginFastifyInstance,
+    workSessionBody: WorkSessionCreate,
+  ): Promise<WorkSessionType> {
+    try {
+      if (workSessionBody._id) {
+        const uuidValid = validate(workSessionBody._id)
+
+        if (!uuidValid) {
+          throw new Error("Invalid ID - not a valid uuid v4")
+        }
+
+        const duplicate = await this.workSessionModel.findById(
+          workSessionBody._id,
+        )
+
+        if (duplicate) {
+          throw new Error("An entry with this id already exists")
+        }
+      } else {
+        workSessionBody._id = uuidv4()
+      }
+
+      const workSession = new this.workSessionModel(workSessionBody)
+
+      await workSession.save()
+
+      fastify.log.info(`[API] Created workSession #${workSession._id}`)
+
+      return workSession.toObject ? workSession.toObject() : workSession
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create a new workSession with payload wrapping and event emission
+   */
+  async createWorkSession(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    workSessionBody: WorkSessionCreate,
+  ): Promise<FrontendPayload<WorkSessionType[]>> {
+    const workSession = await this._createWorkSession(fastify, workSessionBody)
+
+    const payload = await createWorkSessionPayload(
+      fastify,
+      [workSession],
+      requestData,
+    )
+
+    if (requestData.broadcast) {
+      fastify.emit("workSessionCreated", payload)
+    }
+
+    return payload
+  }
+
+  /**
+   * Core function to read all workSessions (returns raw data)
+   */
+  async _readWorkSessions(
+    fastify: PluginFastifyInstance,
+    filter: Record<string, any> = {},
+    options: QueryOptions = {},
+  ): Promise<WorkSessionType[]> {
+    try {
+      // Start building the query
+      let query = this.workSessionModel.find(filter)
+
+      // Apply pagination if provided
+      if (options.limit !== undefined) {
+        query = query.limit(options.limit)
+      }
+      if (options.offset !== undefined) {
+        query = query.skip(options.offset)
+      }
+
+      // Apply population if provided
+      if (options.populate && Array.isArray(options.populate)) {
+        options.populate.forEach((populateOption) => {
+          query = query.populate(populateOption as any)
+        })
+      }
+
+      // Execute query
+      return await query.lean()
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Read all workSessions with payload wrapping
+   */
+  async readWorkSessions(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    filter?: Record<string, any>,
+    options: QueryOptions = {},
+  ): Promise<FrontendPayload<WorkSessionType[]>> {
+    const workSessions = await this._readWorkSessions(fastify, filter, options)
+
+    return createWorkSessionPayload(fastify, workSessions, requestData)
+  }
+
+  /**
+   * Core function to get a specific workSession (returns raw data)
+   */
+  async _readWorkSession(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<WorkSessionType> {
+    try {
+      const workSession = await this.workSessionModel.findById(id).lean()
+
+      if (!workSession) {
+        throw new Error(`WorkSession with ID ${id} not found`)
+      }
+
+      return workSession
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Get a specific workSession with payload wrapping
+   */
+  async readWorkSession(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    id: string,
+  ): Promise<FrontendPayload<WorkSessionType[]>> {
+    const workSession = await this._readWorkSession(fastify, id)
+
+    return createWorkSessionPayload(fastify, [workSession], requestData)
+  }
+
+  /**
+   * Core function to update an existing workSession (returns raw data)
+   */
+  async _updateWorkSession(
+    fastify: PluginFastifyInstance,
+    id: string,
+    workSessionBody: Partial<WorkSessionUpdate>,
+    userId: string,
+  ): Promise<{ updated: WorkSessionType; original: WorkSessionType }> {
+    try {
+      const originalWorkSession = await this.workSessionModel
+        .findById(id)
+        .lean()
+
+      if (!originalWorkSession) {
+        throw new Error(`WorkSession with ID ${id} not found`)
+      }
+      // Remove protected fields
+      const mergedWorkSession = mergeDeepRight(
+        originalWorkSession,
+        workSessionBody,
+      )
+      const updatedWorkSession = await this.workSessionModel
+        .findByIdAndUpdate(
+          id,
+          {
+            pluginData: mergedWorkSession.pluginData,
+            updatedBy: userId,
+          },
+          { new: true },
+        )
+        .lean()
+
+      if (!updatedWorkSession) {
+        throw new Error(`Failed to update workSession with ID ${id}`)
+      }
+
+      fastify.log.info(`[API] Updated workSession #${updatedWorkSession._id}`)
+
+      return {
+        updated: updatedWorkSession,
+        original: originalWorkSession,
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Update an existing workSession with payload wrapping and event emission
+   */
+  async updateWorkSession(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    id: string,
+    workSessionBody: Partial<WorkSessionUpdate>,
+    userId: string,
+  ): Promise<FrontendPayload<WorkSessionType[]>> {
+    const { updated, original } = await this._updateWorkSession(
+      fastify,
+      id,
+      workSessionBody,
+      userId,
+    )
+
+    const payload = await createWorkSessionPayload(
+      fastify,
+      [updated],
+      requestData,
+    )
+    payload.workSessionId = `session_${id}`
+    payload.body.prevVersion = original
+
+    if (requestData.broadcast) {
+      // TODO Discuss if we want to send the full payload here or only the actual changed pluginData, or maybe even introduce a "workstate" object in the workSession document which get's broadcasted and keeps all the worksession relevant state data
+      fastify.emit("workSessionUpdated", payload)
+    }
+
+    return payload
+  }
+
+  /**
+   * Core function to soft delete a workSession (returns raw data)
+   */
+  async _removeWorkSession(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<WorkSessionType> {
+    try {
+      const workSession = await this.workSessionModel
+        .findByIdAndUpdate(id, { isActive: false }, { new: true })
+        .lean()
+
+      if (!workSession) {
+        throw new Error(`WorkSession with ID ${id} not found`)
+      }
+
+      return workSession
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Soft delete a workSession with payload wrapping and event emission
+   */
+  async removeWorkSession(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    id: string,
+  ): Promise<FrontendPayload<WorkSessionType[]>> {
+    const workSession = await this._removeWorkSession(fastify, id)
+
+    const payload = await createWorkSessionPayload(fastify, [workSession], {
+      ...requestData,
+      type: "dataDelete",
+    })
+
+    payload.body.deleted = [workSession._id]
+    fastify.emit("workSessionDeleted", payload)
+
+    return payload
+  }
+
+  /**
+   * Core function to hard delete a workSession (returns raw data)
+   */
+  async _hardDeleteWorkSession(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<WorkSessionType> {
+    try {
+      const workSession = await this.workSessionModel.findById(id)
+
+      if (!workSession) {
+        throw new Error(`WorkSession with ID ${id} not found`)
+      }
+
+      const res = await workSession.deleteOne()
+
+      if (res?.deletedCount === 1) {
+        return workSession.toObject ? workSession.toObject() : workSession
+      }
+
+      throw new Error(
+        `Deletion of WorkSession with ID ${id} was not successful.`,
+      )
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Hard delete a workSession with payload wrapping and event emission
+   */
+  async hardDeleteWorkSession(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    id: string,
+  ): Promise<FrontendPayload<WorkSessionType[]>> {
+    const workSession = await this._hardDeleteWorkSession(fastify, id)
+
+    const payload = await createWorkSessionPayload(fastify, [workSession], {
+      ...requestData,
+      type: "dataHardDeleted",
+    })
+
+    payload.body.deleted = [workSession._id]
+    fastify.emit("workSessionHardDeleted", payload)
+
+    return payload
+  }
+}
+
+export const createWorkSessionService = (model: Model<WorkSessionType>) =>
+  new WorkSessionService(model)

package/services/backend/src/corePlugins/raclette__core/backend/index.ts

@@ -5,6 +5,7 @@ import registerInteractionLink from "./datatypes/interactionLink"
 import registerTag from "./datatypes/tag"
 import registerUser from "./datatypes/user"
 import registerProject from "./datatypes/project"
+import registerWorkSession from "./datatypes/workSession"
 import { PluginContract } from "@c/contracting/contractTypes"
 
 const racletteCorePlugin = async (
@@ -21,6 +22,7 @@ const racletteCorePlugin = async (
     registerProject(fastify),
     registerTag(fastify),
     registerUser(fastify),
+    registerWorkSession(fastify),
   ])
 
   // Combine all contract snippets into one plugin contract

package/services/backend/src/corePlugins/raclette__core/frontend/generated-config.ts

@@ -102,6 +102,18 @@ export default {
             }
           ]
         },
+        updateRestore: {
+          target: (payload) => `/raclette__core/interactionLink/${payload._id}/restore`,
+          method: "patch",
+          storeActionType: "dataRestore",
+          channels: [
+            {
+              channel: "raclette__core--interactionLinkRestored",
+              channelKey: "interactionLinkRestored",
+              prefix: "raclette__core"
+            }
+          ]
+        },
         create: {
           target: "/raclette__core/interactionLink",
           method: "post",
@@ -114,6 +126,18 @@ export default {
             }
           ]
         },
+        createBulk: {
+          target: "/raclette__core/interactionLink/bulk",
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--interactionLinksCreated",
+              channelKey: "interactionLinksCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
         delete: {
           target: (payload) => `/raclette__core/interactionLink/${payload._id}`,
           method: "delete",
@@ -176,30 +200,6 @@ export default {
               prefix: "raclette__core"
             }
           ]
-        },
-        delete: {
-          target: (payload) => `/raclette__core/project/${payload._id}`,
-          method: "delete",
-          storeActionType: "dataUpdate",
-          channels: [
-            {
-              channel: "raclette__core--projectDeleted",
-              channelKey: "projectDeleted",
-              prefix: "raclette__core"
-            }
-          ]
-        },
-        deleteHard: {
-          target: (payload) => `/raclette__core/project/${payload._id}/hard`,
-          method: "delete",
-          storeActionType: "dataHardDeleted",
-          channels: [
-            {
-              channel: "raclette__core--projectHardDeleted",
-              channelKey: "projectHardDeleted",
-              prefix: "raclette__core"
-            }
-          ]
         }
       }
     },
@@ -228,6 +228,18 @@ export default {
             }
           ]
         },
+        updateRestore: {
+          target: (payload) => `/raclette__core/tag/${payload._id}/restore`,
+          method: "patch",
+          storeActionType: "dataRestore",
+          channels: [
+            {
+              channel: "raclette__core--tagRestored",
+              channelKey: "tagRestored",
+              prefix: "raclette__core"
+            }
+          ]
+        },
         create: {
           target: (payload) => `/raclette__core/tag/${payload.project}/${payload._id}`,
           method: "post",
@@ -240,6 +252,18 @@ export default {
             }
           ]
         },
+        createBulk: {
+          target: "/raclette__core/tag/bulk",
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--tagsCreated",
+              channelKey: "tagsCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
         delete: {
           target: (payload) => `/raclette__core/tag/${payload._id}`,
           method: "delete",
@@ -291,6 +315,18 @@ export default {
             }
           ]
         },
+        updateRestore: {
+          target: (payload) => `/raclette__core/user/${payload._id}/restore`,
+          method: "patch",
+          storeActionType: "dataRestore",
+          channels: [
+            {
+              channel: "raclette__core--userRestored",
+              channelKey: "userRestored",
+              prefix: "raclette__core"
+            }
+          ]
+        },
         create: {
           target: "/raclette__core/user",
           method: "post",
@@ -315,6 +351,18 @@ export default {
             }
           ]
         },
+        deleteHard: {
+          target: (payload) => `/raclette__core/user/${payload._id}/hard`,
+          method: "delete",
+          storeActionType: "dataHardDeleted",
+          channels: [
+            {
+              channel: "raclette__core--userHardDeleted",
+              channelKey: "userHardDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        },
         updateLastProject: {
           target: (payload) => `/raclette__core/user/last-project/${payload.projectId}`,
           method: "patch",
@@ -329,6 +377,69 @@ export default {
         }
       }
     },
+    workSession: {
+      type: "workSession",
+      operations: {
+        getAll: {
+          target: "/raclette__core/workSession/all",
+          method: "get",
+          storeActionType: "dataRead"
+        },
+        get: {
+          target: (payload) => `/raclette__core/workSession/${payload._id}`,
+          method: "get",
+          storeActionType: "dataRead"
+        },
+        create: {
+          target: "/raclette__core/workSession",
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--workSessionCreated",
+              channelKey: "workSessionCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        update: {
+          target: (payload) => `/raclette__core/workSession/${payload._id}`,
+          method: "patch",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--workSessionUpdated",
+              channelKey: "workSessionUpdated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        delete: {
+          target: (payload) => `/raclette__core/workSession/${payload._id}`,
+          method: "delete",
+          storeActionType: "dataUpdate",
+          channels: [
+            {
+              channel: "raclette__core--workSessionDeleted",
+              channelKey: "workSessionDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        },
+        deleteHard: {
+          target: (payload) => `/raclette__core/workSession/${payload._id}/hard`,
+          method: "delete",
+          storeActionType: "dataHardDeleted",
+          channels: [
+            {
+              channel: "raclette__core--workSessionHardDeleted",
+              channelKey: "workSessionHardDeleted",
+              prefix: "raclette__core"
+            }
+          ]
+        }
+      }
+    },
     composition: {
       type: "composition",
       operations: {
@@ -354,6 +465,18 @@ export default {
             }
           ]
         },
+        updateRestore: {
+          target: (payload) => `/raclette__core/composition/${payload._id}/restore`,
+          method: "patch",
+          storeActionType: "dataRestore",
+          channels: [
+            {
+              channel: "raclette__core--compositionRestored",
+              channelKey: "compositionRestored",
+              prefix: "raclette__core"
+            }
+          ]
+        },
         create: {
           target: "/raclette__core/composition",
           method: "post",
@@ -366,6 +489,18 @@ export default {
             }
           ]
         },
+        createBulk: {
+          target: "/raclette__core/composition/bulk",
+          method: "post",
+          storeActionType: "dataCreate",
+          channels: [
+            {
+              channel: "raclette__core--compositionsCreated",
+              channelKey: "compositionsCreated",
+              prefix: "raclette__core"
+            }
+          ]
+        },
         delete: {
           target: (payload) => `/raclette__core/composition/${payload._id}`,
           method: "delete",