@raclettejs/core 0.0.1

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

@@ -0,0 +1,335 @@
+import type { Composition as CompositionType } from "./composition.schema"
+import type {
+  ClientPayload,
+  ClientPayloadRequestData,
+} from "@c/payload/payloadTypes"
+import type { PluginFastifyInstance } from "types"
+import { v4 as uuidv4, validate } from "uuid"
+import { createCompositionPayload } from "./helpers/payload"
+import { Model } from "mongoose"
+
+export type CompositionBody = Partial<Omit<CompositionType, "_id">> & {
+  _id?: string
+}
+
+// Using a class to preserve 'this' context
+export class CompositionService {
+  private compositionModel: Model<CompositionType>
+
+  constructor(model: Model<CompositionType>) {
+    this.compositionModel = model
+  }
+  /**
+   * Core function to create a composition (returns raw data)
+   */
+  async _createComposition(
+    fastify: PluginFastifyInstance,
+    compositionBody: CompositionBody,
+    userId: string,
+  ): Promise<CompositionType> {
+    try {
+      if (compositionBody._id) {
+        const uuidValid = validate(compositionBody._id)
+
+        if (!uuidValid) {
+          throw new Error("Invalid ID - not a valid uuid v4")
+        }
+
+        const duplicate = await this.compositionModel.findOne({
+          id: compositionBody._id,
+        })
+
+        if (duplicate) {
+          throw new Error("An entry with this id already exists")
+        }
+      } else {
+        compositionBody._id = uuidv4()
+      }
+
+      const composition = new this.compositionModel({
+        ...compositionBody,
+        author: userId,
+        lastEditor: userId,
+      })
+
+      await composition.save()
+
+      fastify.log.info(`[API] Created composition #${composition._id}`)
+
+      return composition.toObject ? composition.toObject() : composition
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create a new composition with payload wrapping and event emission
+   */
+  async createComposition(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    compositionBody: CompositionBody,
+    userId: string,
+  ): Promise<ClientPayload<CompositionType[]>> {
+    const composition = await this._createComposition(
+      fastify,
+      compositionBody,
+      userId,
+    )
+
+    const payload = await createCompositionPayload(
+      fastify,
+      [composition],
+      requestData,
+    )
+
+    fastify.emit("compositionCreated", payload)
+
+    return payload
+  }
+
+  /**
+   * Core function to get all compositions (returns raw data)
+   */
+  async _readAllCompositions(
+    fastify: PluginFastifyInstance,
+  ): Promise<CompositionType[]> {
+    try {
+      return await this.compositionModel
+        .find({
+          isDeleted: false,
+        })
+        .lean()
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Get all compositions with payload wrapping
+   */
+  async getAllCompositions(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+  ): Promise<ClientPayload<CompositionType[]>> {
+    const compositions = await this._readAllCompositions(fastify)
+
+    return createCompositionPayload(fastify, compositions, requestData)
+  }
+
+  /**
+   * Core function to get a specific composition (returns raw data)
+   */
+  async _readComposition(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<CompositionType> {
+    try {
+      const composition = await this.compositionModel
+        .findOne({ _id: id })
+        .lean()
+
+      if (!composition) {
+        throw new Error(`Composition with ID ${id} not found`)
+      }
+
+      return composition
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Get a specific composition with payload wrapping
+   */
+  async readComposition(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+  ): Promise<ClientPayload<CompositionType[]>> {
+    const composition = await this._readComposition(fastify, id)
+
+    return createCompositionPayload(fastify, [composition], requestData)
+  }
+
+  /**
+   * Core function to update a composition (returns raw data)
+   */
+  async _updateComposition(
+    fastify: PluginFastifyInstance,
+    id: string,
+    compositionBody: CompositionBody,
+    userId: string,
+  ): Promise<{ updated: CompositionType; original: CompositionType }> {
+    try {
+      const originalComposition = await this.compositionModel.findOne({
+        _id: id,
+      })
+
+      if (!originalComposition) {
+        throw new Error(`Composition with ID ${id} not found`)
+      }
+
+      // Remove protected fields
+      delete compositionBody._id
+
+      const updatedComposition = await this.compositionModel
+        .findOneAndUpdate(
+          { _id: id },
+          {
+            ...compositionBody,
+            lastEditor: userId,
+          },
+          { new: true },
+        )
+        .lean()
+
+      if (!updatedComposition) {
+        throw new Error(`Failed to update composition with ID ${id}`)
+      }
+
+      fastify.log.info(`[API] Updated composition #${updatedComposition._id}`)
+
+      return {
+        updated: updatedComposition,
+        original: originalComposition.toObject
+          ? originalComposition.toObject()
+          : originalComposition,
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Update a composition with payload wrapping and event emission
+   */
+  async updateComposition(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+    compositionBody: CompositionBody,
+    userId: string,
+  ): Promise<ClientPayload<CompositionType[]>> {
+    const { updated, original } = await this._updateComposition(
+      fastify,
+      id,
+      compositionBody,
+      userId,
+    )
+
+    const payload = await createCompositionPayload(
+      fastify,
+      [updated],
+      requestData,
+    )
+
+    payload.body.prevVersion = original
+
+    if (requestData.broadcast) {
+      fastify.emit("compositionUpdated", payload)
+    }
+
+    return payload
+  }
+
+  /**
+   * Core function to soft delete a composition (returns raw data)
+   */
+  async _removeComposition(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<CompositionType> {
+    try {
+      const composition = await this.compositionModel
+        .findOneAndUpdate({ _id: id }, { isDeleted: true }, { new: true })
+        .lean()
+
+      if (!composition) {
+        throw new Error(`Composition with ID ${id} not found`)
+      }
+
+      return composition
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Soft delete a composition with payload wrapping and event emission
+   */
+  async removeComposition(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+  ): Promise<ClientPayload<CompositionType[]>> {
+    const composition = await this._removeComposition(fastify, id)
+
+    const payload = await createCompositionPayload(fastify, [composition], {
+      ...requestData,
+      type: "dataDelete",
+    })
+
+    payload.body.deleted = [composition._id]
+    fastify.emit("compositionDeleted", payload)
+
+    return payload
+  }
+
+  /**
+   * Core function to hard delete a composition (returns raw data)
+   */
+  async _hardDeleteComposition(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<CompositionType> {
+    try {
+      const composition = await this.compositionModel.findOne({
+        id,
+        isDeleted: true,
+      })
+
+      if (!composition) {
+        throw new Error(
+          `Composition with ID ${id} not found or not marked for deletion`,
+        )
+      }
+
+      await this.compositionModel.deleteOne({ _id: id })
+
+      return composition.toObject ? composition.toObject() : composition
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Hard delete a composition with payload wrapping and event emission
+   */
+  async hardDeleteComposition(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+  ): Promise<ClientPayload<CompositionType[]>> {
+    const composition = await this._hardDeleteComposition(fastify, id)
+
+    const payload = await createCompositionPayload(fastify, [composition], {
+      ...requestData,
+      type: "dataHardDeleted",
+    })
+
+    payload.body.deleted = [composition._id]
+    fastify.emit("compositionHardDeleted", payload)
+
+    return payload
+  }
+}
+
+export const createCompositionService = (model: Model<CompositionType>) =>
+  new CompositionService(model)

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

@@ -0,0 +1,33 @@
+import type { AnyComposition } from "../composition.schema"
+import type { ClientPayload } from "@c/payload/payloadTypes"
+import type { PluginFastifyInstance } from "types"
+
+export const registerEvents = (fastify: PluginFastifyInstance) => {
+  /*
+   * composition created and created
+   */
+  const created = async (payload: ClientPayload<AnyComposition>) => {
+    fastify.eventbus.emit("broadcastCompositionCreated", payload)
+    fastify.log.info(
+      `[eventbus] composition broadcast created ${payload.body.items}`,
+    )
+  }
+
+  /*
+   * composition deleted
+   */
+  const deleted = async (payload: ClientPayload<AnyComposition>) => {
+    fastify.eventbus.emit("broadcastCompositionDeleted", payload)
+    fastify.log.info(
+      `[eventbus] composition broadcast deleted ${payload.body.items}`,
+    )
+  }
+
+  /**
+   * Register those functions for eventbus events
+   */
+  fastify.eventbus.on("coreCompositionCreated", created)
+  fastify.eventbus.on("coreCompositionDeleted", deleted)
+}
+
+export default registerEvents

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

@@ -0,0 +1,13 @@
+import type { PluginFastifyInstance } from "types"
+
+export const registerCrud = (fastify: PluginFastifyInstance) => {
+  const compositionService = fastify.custom.compositionService
+
+  fastify.registerCrudHandlers("composition", {
+    create: compositionService.createComposition,
+    read: compositionService.readComposition,
+    readAll: compositionService.getAllCompositions,
+    update: compositionService.updateComposition,
+    delete: compositionService.removeComposition,
+  })
+}

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

@@ -0,0 +1,19 @@
+import type { Composition } from "../composition.schema"
+import type { ClientPayloadRequestData, PluginFastifyInstance } from "types"
+
+export const registerPayload = (fastify: PluginFastifyInstance) => {
+  fastify.registerPayloadHandler<Composition>("composition", {
+    type: "composition",
+    displayName: (composition: Composition) => composition.title || "",
+    completion: (composition: Composition) => composition.title || "",
+    fields: (item: Composition) => ({
+      owner: item.author,
+    }),
+  })
+}
+
+export const createCompositionPayload = async (
+  fastify: PluginFastifyInstance,
+  items: Composition[],
+  requestData: ClientPayloadRequestData,
+) => await fastify.createPayload("composition", items, requestData)

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

@@ -0,0 +1,59 @@
+import type { PluginFastifyInstance } from "types"
+import registerRoutes from "./routes"
+import { createModels } from "./composition.model"
+import { createCompositionService } from "./composition.service"
+import { registerPayload } from "./helpers/payload"
+import { registerCrud } from "./helpers/crud"
+import { compositionSchema, registerSchemas } from "./composition.schema"
+
+const registerComposition = async (fastify: PluginFastifyInstance) => {
+  /*
+   * ---------------------------------------------------------------------
+   * CREATE AND REGISTER ALL YOUR MODELS
+   * ---------------------------------------------------------------------
+   */
+  const compositionModel = createModels(fastify)
+
+  // create and pass in the model to your service
+  const compositionService = await createCompositionService(compositionModel)
+
+  // decorate the service to the instance, so we can easily call it everywhere
+  fastify.custom.compositionService = compositionService
+
+  /*
+   * ---------------------------------------------------------------------
+   * 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
+  }
+
+  registerSchemas(fastify)
+  registerPayload(fastify)
+  registerCrud(fastify)
+
+  return {
+    composition: {
+      schema: compositionSchema,
+      operations: {
+        readAll:
+          compositionService._readAllCompositions.bind(compositionService),
+        read: compositionService._readComposition.bind(compositionService),
+        create: compositionService._createComposition.bind(compositionService),
+        update: compositionService._updateComposition.bind(compositionService),
+        delete: compositionService._removeComposition.bind(compositionService),
+      },
+      keywords: ["composition", "content", "layout", "structure"],
+      metadata: {
+        description: "Core composition management",
+        version: "1.0.0",
+      },
+    },
+  }
+}
+
+export default registerComposition

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

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

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

@@ -0,0 +1,53 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { 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 compositionService = fastify.custom.compositionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { _id } = req.params
+
+      const payload = await compositionService.readComposition(
+        fastify,
+        req.requestParams,
+        _id,
+      )
+
+      if (!payload) {
+        return reply.notFound("Composition not found")
+      }
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataPush",
+    },
+    schema: {
+      summary: "Get a composition by id",
+      tags: ["core/composition"],
+
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -0,0 +1,33 @@
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+
+export default (fastify: PluginFastifyInstance) => {
+  const compositionService = fastify.custom.compositionService
+
+  const handler = async (req: FastifyRequest, reply: FastifyReply) => {
+    try {
+      const payload = await compositionService.getAllCompositions(
+        fastify,
+        req.requestParams,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataPush",
+    },
+    schema: {
+      summary: "Get all compositions",
+      tags: ["core/composition"],
+      params: {},
+    },
+  }
+}

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

@@ -0,0 +1,50 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { 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 compositionService = fastify.custom.compositionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { _id } = req.params
+
+      const payload = await compositionService.hardDeleteComposition(
+        fastify,
+        req.requestParams,
+        _id,
+      )
+
+      return payload
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataHardDelete",
+      broadcastChannels: ["compositionHardDeleted"],
+    },
+    schema: {
+      summary: "Hard delete a composition",
+      tags: ["core/composition"],
+
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -0,0 +1,58 @@
+import type { CompositionBody } from "../composition.service"
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+import { compositionUpdateSchema } from "../composition.schema"
+
+const ParamsSchema = Type.Object({
+  _id: Type.String(),
+})
+
+type Params = Static<typeof ParamsSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const compositionService = fastify.custom.compositionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+      Body: CompositionBody
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { _id } = req.params
+
+      const payload = await compositionService.updateComposition(
+        fastify,
+        req.requestParams,
+        _id,
+        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],
+    config: {
+      type: "dataUpdate",
+      broadcastChannels: ["compositionUpdated"],
+    },
+    schema: {
+      summary: "Update a composition",
+      tags: ["core/composition"],
+
+      params: ParamsSchema,
+      body: compositionUpdateSchema,
+    },
+  }
+}