@raclettejs/core 0.1.18 → 0.1.20

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/tag/routes/route.tag.post.bulk.ts

@@ -0,0 +1,60 @@
+import type { TagBody } from "../tag.service"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { tagCreateSchema } from "../tag.schema"
+
+const permissions = ["user.isAdmin"]
+
+export default (fastify: PluginFastifyInstance) => {
+  const tagService = fastify.custom.tagService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Body: TagBody[]
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      // Validate that body is an array
+      if (!Array.isArray(req.body)) {
+        return reply.badRequest("Request body must be an array of tags")
+      }
+
+      // Validate that array is not empty
+      if (req.body.length === 0) {
+        return reply.badRequest("Request body cannot be an empty array")
+      }
+
+      const payload = await tagService.createTags(
+        fastify,
+        req.requestParams,
+        req.body,
+        req.user._id,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
+    config: {
+      type: "dataCreate",
+      broadcastChannels: ["tagsCreated"],
+    },
+    schema: {
+      summary: "Create multiple tags in bulk",
+      tags: ["core/tag"],
+      body: {
+        type: "array",
+        items: tagCreateSchema,
+        minItems: 1,
+      },
+    },
+  }
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/tag/routes/route.tag.post.ts

@@ -4,6 +4,8 @@ import { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
 import { tagCreateSchema, type TagCreate } from "../tag.schema"
 
+const permissions = ["user.isAdmin"]
+
 const ParamsSchema = Type.Object({
   _id: Type.String(),
   project: Type.String(),
@@ -38,7 +40,7 @@ export default (fastify: PluginFastifyInstance) => {
 
   return {
     handler,
-    onRequest: [fastify.authenticate],
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
     config: {
       type: "dataCreate",
       broadcastChannels: ["tagCreated"],

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/tag/routes/route.tag.remove.ts

@@ -3,6 +3,8 @@ import type { FastifyReply, FastifyRequest } from "fastify"
 import { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
 
+const permissions = ["user.isAdmin"]
+
 const ParamsSchema = Type.Object({
   _id: Type.String(),
 })
@@ -33,7 +35,7 @@ export default (fastify: PluginFastifyInstance) => {
 
   return {
     handler,
-    onRequest: [fastify.authenticate],
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
     config: {
       type: "dataUpdate",
       broadcastChannels: ["tagDeleted"],

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/tag/routes/route.tag.restore.ts

@@ -2,7 +2,8 @@ import type { Static } from "@sinclair/typebox"
 import type { FastifyReply, FastifyRequest } from "fastify"
 import { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
-import { ForbiddenError } from "@/utils/errors"
+
+const permissions = ["user.isAdmin"]
 
 const ParamsSchema = Type.Object({
   _id: Type.String(),
@@ -17,21 +18,17 @@ export default (fastify: PluginFastifyInstance) => {
     reply: FastifyReply,
   ) => {
     try {
-      if (req.user.isAdmin) {
-        const { _id } = req.params
+      const { _id } = req.params
 
-        const payload = await tagService.updateTag(
-          fastify,
-          req.requestParams,
-          _id,
-          { isDeleted: false },
-          req.user._id,
-        )
+      const payload = await tagService.updateTag(
+        fastify,
+        req.requestParams,
+        _id,
+        { isDeleted: false },
+        req.user._id,
+      )
 
-        return payload
-      } else {
-        throw new ForbiddenError("Only admins can restore this core datatype")
-      }
+      return payload
     } catch (error: any) {
       fastify.log.error(error.message)
       return reply.internalServerError(error.message)
@@ -40,7 +37,7 @@ export default (fastify: PluginFastifyInstance) => {
 
   return {
     handler,
-    onRequest: [fastify.authenticate],
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
     config: {
       type: "dataRestore",
       broadcastChannels: ["tagRestored"],

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

@@ -8,7 +8,9 @@ import type { PluginFastifyInstance } from "types"
 import { v4 as uuidv4, validate } from "uuid"
 import { createTagPayload } from "./helpers/payload"
 import type { Model } from "mongoose"
-
+export type TagBody = Partial<Omit<TagType, "_id">> & {
+  _id?: string
+}
 export class TagService {
   private tagModel: Model<TagType>
 
@@ -131,8 +133,7 @@ export class TagService {
     options: QueryOptions = {},
   ): Promise<TagType[]> {
     try {
-      if (filter.isDeleted !== true && filter.isDeleted !== "true")
-        filter.isDeleted = false
+      filter = { isDeleted: false, ...filter }
       // Start building the query
       let query = this.tagModel.find(filter)
 
@@ -369,6 +370,75 @@ export class TagService {
 
     fastify.emit("tagHardDeleted", payload)
 
+    return payload
+  }
+  /**
+   * Core function to create multiple tags (returns raw data)
+   */
+  async _createTags(
+    fastify: PluginFastifyInstance,
+    tagBodies: TagBody[],
+    userId: string,
+  ): Promise<TagType[]> {
+    try {
+      const tagsToCreate: TagBody[] = []
+
+      // Validate and prepare all tags
+      for (const tagBody of tagBodies) {
+        if (tagBody._id) {
+          const uuidValid = validate(tagBody._id)
+
+          if (!uuidValid) {
+            throw new Error(`Invalid ID - not a valid uuid v4: ${tagBody._id}`)
+          }
+
+          const duplicate = await this.tagModel.findOne({
+            _id: tagBody._id,
+          })
+
+          if (duplicate) {
+            throw new Error(
+              `An entry with this id already exists: ${tagBody._id}`,
+            )
+          }
+        } else {
+          tagBody._id = uuidv4()
+        }
+
+        tagsToCreate.push({
+          ...tagBody,
+          author: userId,
+          lastEditor: userId,
+        })
+      }
+
+      // Bulk insert
+      const tags = await this.tagModel.insertMany(tagsToCreate)
+
+      fastify.log.info(`[API] Created ${tags.length} tags in bulk`)
+
+      return tags.map((comp) => (comp.toObject ? comp.toObject() : comp))
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create multiple tags with payload wrapping and event emission
+   */
+  async createTags(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    tagBodies: TagBody[],
+    userId: string,
+  ): Promise<FrontendPayload<TagType[]>> {
+    const tags = await this._createTags(fastify, tagBodies, userId)
+
+    const payload = await createTagPayload(fastify, tags, requestData)
+
+    fastify.emit("tagsCreated", payload)
+
     return payload
   }
 }

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.get.ts

@@ -2,6 +2,7 @@ import type { Static } from "@sinclair/typebox"
 import type { FastifyReply, FastifyRequest } from "fastify"
 import { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
+import { ForbiddenError } from "@/utils/errors"
 
 const ParamsSchema = Type.Object({
   _id: Type.String(),

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.getAll.ts

@@ -2,6 +2,7 @@ import type { Static } from "@sinclair/typebox"
 import type { FastifyReply, FastifyRequest } from "fastify"
 import { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
+import { ForbiddenError } from "@/utils/errors"
 
 const QuerySchema = Type.Object({
   account: Type.Optional(Type.String()),

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.hardDelete.ts

@@ -2,7 +2,8 @@ import type { Static } from "@sinclair/typebox"
 import type { FastifyReply, FastifyRequest } from "fastify"
 import { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
-import { ForbiddenError } from "@/utils/errors"
+
+const permissions = ["user.isAdmin"]
 
 const ParamsSchema = Type.Object({
   _id: Type.String(),
@@ -17,21 +18,15 @@ export default (fastify: PluginFastifyInstance) => {
     reply: FastifyReply,
   ) => {
     try {
-      if (req.user.isAdmin) {
-        const { _id } = req.params
+      const { _id } = req.params
 
-        const payloadWithUser = await userService.hardDeleteUser(
-          fastify,
-          req.requestParams,
-          _id,
-        )
+      const payloadWithUser = await userService.hardDeleteUser(
+        fastify,
+        req.requestParams,
+        _id,
+      )
 
-        return payloadWithUser
-      } else {
-        throw new ForbiddenError(
-          "Only admins can hard delete this core datatype",
-        )
-      }
+      return payloadWithUser
     } catch (error: any) {
       fastify.log.error(error.message)
       return reply.internalServerError(error.message)
@@ -40,7 +35,7 @@ export default (fastify: PluginFastifyInstance) => {
 
   return {
     handler,
-    onRequest: [fastify.authenticate],
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
     config: {
       type: "dataHardDeleted",
       broadcastChannels: ["userHardDeleted"],

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.patch.ts

@@ -4,6 +4,8 @@ import type { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
 import { userUpdateSchema } from "../user.schema"
 
+const permissions = ["user.isAdmin"]
+
 const ParamsSchema = Type.Object({
   _id: Type.String(),
 })
@@ -22,15 +24,11 @@ export default (fastify: PluginFastifyInstance) => {
     reply: FastifyReply,
   ) => {
     try {
-      let cleanBody = req.body
-      if (!req.user.isAdmin) {
-        delete cleanBody.tags
-      }
       const payloadWithUser = await userService.updateUser(
         fastify,
         req.requestParams,
         req.params._id,
-        cleanBody,
+        req.body,
       )
 
       return payloadWithUser
@@ -42,7 +40,7 @@ export default (fastify: PluginFastifyInstance) => {
 
   return {
     handler,
-    onRequest: [fastify.authenticate],
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
     config: {
       type: "dataUpdate",
       broadcastChannels: ["userUpdated"],

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.patchLastProject.ts

@@ -1,7 +1,9 @@
 import type { FastifyReply, FastifyRequest } from "fastify"
-import { PluginFastifyInstance } from "types"
+import type { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
 
+const permissions = ["user.isAdmin"]
+
 export default (fastify: PluginFastifyInstance) => {
   const userService = fastify.custom.userService
 
@@ -26,7 +28,7 @@ export default (fastify: PluginFastifyInstance) => {
 
   return {
     handler,
-    onRequest: [fastify.authenticate],
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
     config: {
       type: "dataUpdate",
       broadcastChannels: ["userUpdated"],

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.post.ts

@@ -2,6 +2,8 @@ import type { FastifyReply, FastifyRequest } from "fastify"
 import { PluginFastifyInstance } from "types"
 import { userCreateSchema, type UserCreate } from "../user.schema"
 
+const permissions = ["user.isAdmin"]
+
 export default (fastify: PluginFastifyInstance) => {
   const userService = fastify.custom.userService
 
@@ -25,7 +27,7 @@ export default (fastify: PluginFastifyInstance) => {
 
   return {
     handler,
-    onRequest: [fastify.authenticate],
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
     config: {
       type: "dataCreate",
       broadcastChannels: ["userCreated"],

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.remove.ts

@@ -4,6 +4,8 @@ import { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
 import { ForbiddenError } from "@/utils/errors"
 
+const permissions = ["user.isAdmin"]
+
 const ParamsSchema = Type.Object({
   _id: Type.String(),
 })
@@ -19,9 +21,6 @@ export default (fastify: PluginFastifyInstance) => {
     reply: FastifyReply,
   ) => {
     try {
-      if (!req.user.isAdmin) {
-        throw new ForbiddenError("Only Admins can use this feature")
-      }
       if (req.user._id === req.params._id) {
         throw new ForbiddenError("A user cannot remove itself")
       }
@@ -41,7 +40,7 @@ export default (fastify: PluginFastifyInstance) => {
 
   return {
     handler,
-    onRequest: [fastify.authenticate],
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
     config: {
       type: "dataDelete",
       broadcastChannels: ["userDeleted"],

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.restore.ts

@@ -2,7 +2,8 @@ import type { Static } from "@sinclair/typebox"
 import type { FastifyReply, FastifyRequest } from "fastify"
 import { PluginFastifyInstance } from "types"
 import { Type } from "@sinclair/typebox"
-import { ForbiddenError } from "@/utils/errors"
+
+const permissions = ["user.isAdmin"]
 
 const ParamsSchema = Type.Object({
   _id: Type.String(),
@@ -17,21 +18,17 @@ export default (fastify: PluginFastifyInstance) => {
     reply: FastifyReply,
   ) => {
     try {
-      if (req.user.isAdmin) {
-        const { _id } = req.params
+      const { _id } = req.params
 
-        const payload = await userService.updateUser(
-          fastify,
-          req.requestParams,
-          _id,
-          { isDeleted: false },
-          req.user._id,
-        )
+      const payload = await userService.updateUser(
+        fastify,
+        req.requestParams,
+        _id,
+        { isDeleted: false },
+        req.user._id,
+      )
 
-        return payload
-      } else {
-        throw new ForbiddenError("Only admins can restore this core datatype")
-      }
+      return payload
     } catch (error: any) {
       fastify.log.error(error.message)
       return reply.internalServerError(error.message)
@@ -40,7 +37,7 @@ export default (fastify: PluginFastifyInstance) => {
 
   return {
     handler,
-    onRequest: [fastify.authenticate],
+    onRequest: [fastify.authenticate, fastify.checkPermissions(permissions)],
     config: {
       type: "dataRestore",
       broadcastChannels: ["userRestored"],

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/events/index.ts

@@ -0,0 +1,45 @@
+import type { AnyWorkSession } from "../workSession.schema"
+import type { FrontendPayload } from "@c/payload/payloadTypes"
+import { PluginFastifyInstance } from "types"
+
+const registerEvents = (fastify: PluginFastifyInstance) => {
+  /**
+   * WorkSession created
+   */
+  const created = async (payload: FrontendPayload<AnyWorkSession>) => {
+    fastify.eventbus.emit("broadcastDataUpdated", payload)
+    fastify.eventbus.emit("broadcastWorkSessionCreated", payload)
+    fastify.log.info(
+      `[eventbus] workSession broadcast created ${payload.body.item._id}`,
+    )
+  }
+
+  /**
+   * WorkSession updated
+   */
+  const updated = async (payload: FrontendPayload<AnyWorkSession>) => {
+    fastify.eventbus.emit("broadcastDataUpdated", payload)
+    fastify.log.info(
+      `[eventbus] workSession broadcast updated ${payload.body.item._id}`,
+    )
+  }
+
+  /**
+   * WorkSession deleted
+   */
+  const deleted = async (payload: FrontendPayload<AnyWorkSession>) => {
+    fastify.eventbus.emit("broadcastWorkSessionDeleted", payload)
+    fastify.log.info(
+      `[eventbus] workSession broadcast deleted ${payload.body.item._id}`,
+    )
+  }
+
+  /**
+   * Register event handlers
+   */
+  fastify.eventbus.on("coreWorkSessionCreated", created)
+  fastify.eventbus.on("coreWorkSessionUpdated", updated)
+  fastify.eventbus.on("coreWorkSessionDeleted", deleted)
+}
+
+export default registerEvents

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/helpers/crud.ts

@@ -0,0 +1,12 @@
+import type { PluginFastifyInstance } from "@raclettejs/core"
+
+export const registerCrud = (fastify: PluginFastifyInstance) => {
+  const workSessionService = fastify.custom.workSessionService
+
+  fastify.registerCrudHandlers("workSession", {
+    create: workSessionService.createWorkSession,
+    read: workSessionService.readWorkSession,
+    update: workSessionService.updateWorkSession,
+    delete: workSessionService.removeWorkSession,
+  })
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/helpers/payload.ts

@@ -0,0 +1,21 @@
+import type { WorkSession } from "../workSession.schema"
+import type { FrontendPayloadRequestData, PluginFastifyInstance } from "types"
+
+export const registerPayload = (fastify: PluginFastifyInstance) => {
+  fastify.registerPayloadHandler<WorkSession>("workSession", {
+    type: "workSession",
+    displayName: (workSession: WorkSession) => workSession._id || "",
+    completion: (workSession: WorkSession) => workSession._id || "",
+    fields: () => ({
+      owner: "NONE",
+    }),
+  })
+}
+
+export const createWorkSessionPayload = async (
+  fastify: PluginFastifyInstance,
+  items: WorkSession[],
+  requestData: FrontendPayloadRequestData,
+) => {
+  return await fastify.createPayload("workSession", items, requestData)
+}

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

@@ -0,0 +1,55 @@
+import { PluginFastifyInstance } from "types"
+import registerRoutes from "./routes"
+import { createModels } from "./workSession.model"
+import { createWorkSessionService } from "./workSession.service"
+import { registerPayload } from "./helpers/payload"
+import { registerCrud } from "./helpers/crud"
+import { registerSchemas } from "./workSession.schema"
+
+const registerWorkSession = async (fastify: PluginFastifyInstance) => {
+  /*
+   * ---------------------------------------------------------------------
+   * CREATE AND REGISTER ALL YOUR MODELS
+   * ---------------------------------------------------------------------
+   */
+  const workSessionModel = createModels(fastify)
+
+  // create and pass in the model to your service
+  const workSessionService = createWorkSessionService(workSessionModel)
+
+  // decorate the service to the instance, so we can easily call it everywhere
+  fastify.custom.workSessionService = workSessionService
+
+  /*
+   * ---------------------------------------------------------------------
+   * REGISTER ALL YOUR ROUTES
+   * ---------------------------------------------------------------------
+   */
+  try {
+    await fastify.register((instance) => registerRoutes(instance))
+  } catch (error) {
+    fastify.log.error(`Failed to register routes.`, error)
+    throw error // Let the application handle the error
+  }
+
+  registerPayload(fastify)
+  registerCrud(fastify)
+  registerSchemas(fastify)
+
+  return {
+    workSession: {
+      operations: {
+        read: workSessionService._readWorkSession.bind(workSessionService),
+        readAll: workSessionService._readWorkSessions.bind(workSessionService),
+        create: workSessionService._createWorkSession.bind(workSessionService),
+        update: workSessionService._updateWorkSession.bind(workSessionService),
+      },
+      keywords: ["workSession", "session"],
+      metadata: {
+        description: "A work session for user interactions.",
+      },
+    },
+  }
+}
+
+export default registerWorkSession

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/routes/index.ts

@@ -0,0 +1,19 @@
+import { PluginFastifyInstance } from "types"
+import get from "./route.workSession.get"
+import getAll from "./route.workSession.getAll"
+import patch from "./route.workSession.patch"
+import post from "./route.workSession.post"
+import hardDelete from "./route.workSession.hardDelete"
+import remove from "./route.workSession.remove"
+
+const registerRoutes = async (fastify: PluginFastifyInstance) => {
+  await fastify.get("/workSession/all", getAll(fastify))
+  await fastify.get("/workSession/:_id", get(fastify))
+
+  await fastify.post("/workSession", post(fastify))
+  await fastify.patch("/workSession/:_id", patch(fastify))
+  await fastify.delete("/workSession/:_id", remove(fastify))
+  await fastify.delete("/workSession/:_id/hard", hardDelete(fastify))
+}
+
+export default registerRoutes

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/workSession/routes/route.workSession.get.ts

@@ -0,0 +1,53 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+
+const ParamsSchema = Type.Object({
+  _id: Type.String(),
+})
+type Params = Static<typeof ParamsSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const workSessionService = fastify.custom.workSessionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { _id } = req.params
+
+      const payload = await workSessionService.readWorkSession(
+        fastify,
+        req.requestParams,
+        _id,
+      )
+
+      if (!payload) {
+        return reply.notFound("WorkSession not found")
+      }
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataRead",
+    },
+    schema: {
+      summary: "Get a workSession by id",
+      tags: ["core/workSession"],
+
+      params: ParamsSchema,
+    },
+  }
+}