@raclettejs/core 0.0.1

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

@@ -0,0 +1,50 @@
+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 interactionLinkService = fastify.custom.interactionLinkService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: Params
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { _id } = req.params
+
+      const payload = await interactionLinkService.removeInteractionLink(
+        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: "dataDelete",
+      broadcastChannels: ["interactionLinkDeleted"],
+    },
+    schema: {
+      summary: "Soft delete a interactionLink",
+      tags: ["core/interactionLink"],
+
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -0,0 +1,45 @@
+import type { AnyProject } from "../project.schema"
+import type { ClientPayload } from "@c/payload/payloadTypes"
+import { PluginFastifyInstance } from "types"
+
+const registerEvents = (fastify: PluginFastifyInstance) => {
+  /**
+   * Project created
+   */
+  const created = async (payload: ClientPayload<AnyProject>) => {
+    fastify.eventbus.emit("broadcastDataUpdated", payload)
+    fastify.eventbus.emit("broadcastProjectCreated", payload)
+    fastify.log.info(
+      `[eventbus] project broadcast created ${payload.body.item._id}`,
+    )
+  }
+
+  /**
+   * Project updated
+   */
+  const updated = async (payload: ClientPayload<AnyProject>) => {
+    fastify.eventbus.emit("broadcastDataUpdated", payload)
+    fastify.log.info(
+      `[eventbus] project broadcast updated ${payload.body.item._id}`,
+    )
+  }
+
+  /**
+   * Project deleted
+   */
+  const deleted = async (payload: ClientPayload<AnyProject>) => {
+    fastify.eventbus.emit("broadcastProjectDeleted", payload)
+    fastify.log.info(
+      `[eventbus] project broadcast deleted ${payload.body.item._id}`,
+    )
+  }
+
+  /**
+   * Register event handlers
+   */
+  fastify.eventbus.on("coreProjectCreated", created)
+  fastify.eventbus.on("coreProjectUpdated", updated)
+  fastify.eventbus.on("coreProjectDeleted", deleted)
+}
+
+export default registerEvents

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

@@ -0,0 +1,12 @@
+import type { PluginFastifyInstance } from "@raclettejs/core"
+
+export const registerCrud = (fastify: PluginFastifyInstance) => {
+  const projectService = fastify.custom.projectService
+
+  fastify.registerCrudHandlers("project", {
+    create: projectService.createProject,
+    read: projectService.readProject,
+    update: projectService.updateProject,
+    delete: projectService.removeProject,
+  })
+}

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

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

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

@@ -0,0 +1,56 @@
+import { PluginFastifyInstance } from "types"
+import registerRoutes from "./routes"
+import { createModels } from "./project.model"
+import { createProjectService } from "./project.service"
+import { registerPayload } from "./helpers/payload"
+import { registerCrud } from "./helpers/crud"
+import { registerSchemas } from "./project.schema"
+
+const registerProject = async (fastify: PluginFastifyInstance) => {
+  /*
+   * ---------------------------------------------------------------------
+   * CREATE AND REGISTER ALL YOUR MODELS
+   * ---------------------------------------------------------------------
+   */
+  const projectModel = createModels(fastify)
+
+  // create and pass in the model to your service
+  const projectService = createProjectService(projectModel)
+
+  // decorate the service to the instance, so we can easily call it everywhere
+  fastify.custom.projectService = projectService
+
+  /*
+   * ---------------------------------------------------------------------
+   * 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 {
+    project: {
+      operations: {
+        read: projectService._readProject.bind(projectService),
+        readMain: projectService._readMainProject.bind(projectService),
+        readAll: projectService._readProjects.bind(projectService),
+        create: projectService._createProject.bind(projectService),
+        update: projectService._updateProject.bind(projectService),
+      },
+      keywords: ["project", "space"],
+      metadata: {
+        description: "The space the user is using the app in.",
+      },
+    },
+  }
+}
+
+export default registerProject

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/project/project.model.ts

@@ -0,0 +1,43 @@
+import { PluginFastifyInstance } from "types"
+import mongoose from "mongoose"
+const { Schema } = mongoose
+
+export const MODEL_BASENAME = "project"
+
+const projectSchema = new Schema(
+  {
+    _id: {
+      type: String,
+    },
+
+    title: {
+      type: String,
+      required: true,
+      maxLength: 200,
+    },
+
+    account: {
+      type: Schema.Types.String,
+      ref: "raclette__core-account",
+      default: null,
+    },
+
+    tags: {
+      type: [Schema.Types.String],
+      ref: "raclette__core-tag",
+      default: [],
+    },
+
+    description: { type: String },
+
+    isDefault: { type: Boolean, default: false },
+
+    // soft delete
+    isDeleted: { type: Boolean, default: false },
+  },
+  { timestamps: true },
+)
+
+export const createModels = (fastify: PluginFastifyInstance) => {
+  return fastify.createModel(MODEL_BASENAME, projectSchema)
+}

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/project/project.schema.ts

@@ -0,0 +1,107 @@
+import type { Static } from "@sinclair/typebox"
+import type { Document } from "mongoose"
+import { Type } from "@sinclair/typebox"
+import { PluginFastifyInstance } from "types"
+
+/**
+ * Base Project Schema - Fields common to all operations
+ */
+const baseProjectSchema = {
+  title: Type.Optional(Type.String({ maxLength: 200 })),
+  account: Type.Optional(Type.String({ default: null })),
+  tags: Type.Optional(Type.Array(Type.String(), { default: [] })),
+  description: Type.Optional(Type.String()),
+  isDefault: Type.Optional(Type.Boolean({ default: false })),
+}
+
+/**
+ * Full Project Schema - Used for response serialization and database model
+ */
+export const projectSchema = Type.Object(
+  {
+    _id: Type.String(),
+    ...baseProjectSchema,
+    isDeleted: Type.Boolean({ default: false }),
+    createdAt: Type.String({ format: "date-time" }),
+    updatedAt: Type.String({ format: "date-time" }),
+  },
+  {
+    $id: "#project/base",
+    title: "core/project",
+  },
+)
+
+/**
+ * Project Create Schema - For POST operations
+ */
+export const projectCreateSchema = Type.Object(
+  {
+    _id: Type.Optional(Type.String()),
+    ...baseProjectSchema,
+  },
+  {
+    $id: "#project/create",
+    title: "core/project-create",
+  },
+)
+
+/**
+ * Project Update Schema - For PATCH operations
+ */
+export const projectUpdateSchema = Type.Object(
+  {
+    _id: Type.Optional(Type.String()),
+    title: Type.Optional(Type.String({ maxLength: 200 })),
+    account: Type.Optional(Type.String()),
+    tags: Type.Optional(Type.Array(Type.String())),
+    description: Type.Optional(Type.String()),
+    isDefault: Type.Optional(Type.Boolean()),
+  },
+  {
+    $id: "#project/update",
+    title: "core/project-update",
+  },
+)
+
+/**
+ * Type Utilities
+ */
+
+type DateTimeFields = {
+  createdAt: Date
+  updatedAt: Date
+}
+
+type RawProject = Static<typeof projectSchema>
+export type Project = Omit<RawProject, keyof DateTimeFields> & DateTimeFields
+
+type RawProjectCreate = Static<typeof projectCreateSchema>
+export type ProjectCreate = RawProjectCreate
+
+type RawProjectUpdate = Static<typeof projectUpdateSchema>
+export type ProjectUpdate = RawProjectUpdate
+
+export interface ProjectDoc extends Document, Project {
+  _id: string
+}
+export type AnyProject = Project | ProjectDoc
+
+/**
+ * Register Schema/Type Generation for Shared Folder
+ */
+export const registerSchemas = (fastify: PluginFastifyInstance) => {
+  fastify.registerSchema({
+    schema: projectSchema,
+    name: "Project",
+  })
+
+  fastify.registerSchema({
+    schema: projectCreateSchema,
+    name: "ProjectCreate",
+  })
+
+  fastify.registerSchema({
+    schema: projectUpdateSchema,
+    name: "ProjectUpdate",
+  })
+}

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

@@ -0,0 +1,351 @@
+import type {
+  ProjectCreate,
+  Project as ProjectType,
+  ProjectUpdate,
+} from "./project.schema"
+import type {
+  ClientPayload,
+  ClientPayloadRequestData,
+} from "@c/payload/payloadTypes"
+import type { QueryOptions } from "@m/database/providers/mongodb/service"
+import { v4 as uuidv4, validate } from "uuid"
+import { createProjectPayload } from "./helpers/payload"
+import { Model } from "mongoose"
+import { PluginFastifyInstance } from "types"
+
+export type ProjectBody = Partial<Omit<ProjectType, "_id">> & { _id?: string }
+
+// Using a class to preserve 'this' context
+export class ProjectService {
+  private projectModel: Model<ProjectType>
+
+  constructor(model: Model<ProjectType>) {
+    this.projectModel = model
+  }
+  /**
+   * Core function to create a new project (returns raw data)
+   */
+  async _createProject(
+    fastify: PluginFastifyInstance,
+    projectBody: ProjectCreate,
+  ): Promise<ProjectType> {
+    try {
+      if (projectBody._id) {
+        const uuidValid = validate(projectBody._id)
+
+        if (!uuidValid) {
+          throw new Error("Invalid ID - not a valid uuid v4")
+        }
+
+        const duplicate = await this.projectModel.findById(projectBody._id)
+
+        if (duplicate) {
+          throw new Error("An entry with this id already exists")
+        }
+      } else {
+        projectBody._id = uuidv4()
+      }
+
+      const project = new this.projectModel(projectBody)
+
+      await project.save()
+
+      fastify.log.info(`[API] Created project #${project._id}`)
+
+      return project.toObject ? project.toObject() : project
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create a new project with payload wrapping and event emission
+   */
+  async createProject(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    projectBody: ProjectCreate,
+  ): Promise<ClientPayload<ProjectType[]>> {
+    const project = await this._createProject(fastify, projectBody)
+
+    const payload = await createProjectPayload(fastify, [project], requestData)
+
+    if (requestData.broadcast) {
+      fastify.emit("projectCreated", payload)
+    }
+
+    return payload
+  }
+
+  /**
+   * Core function to read all projects (returns raw data)
+   */
+  async _readProjects(
+    fastify: PluginFastifyInstance,
+    filter: Record<string, any> = { isDeleted: false },
+    options: QueryOptions = {},
+  ): Promise<ProjectType[]> {
+    try {
+      // Start building the query
+      let query = this.projectModel.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 projects with payload wrapping
+   */
+  async readProjects(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    filter?: Record<string, any>,
+    options: QueryOptions = {},
+  ): Promise<ClientPayload<ProjectType[]>> {
+    const projects = await this._readProjects(fastify, filter, options)
+
+    return createProjectPayload(fastify, projects, requestData)
+  }
+
+  /**
+   * Core function to get a specific project (returns raw data)
+   */
+  async _readProject(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<ProjectType> {
+    try {
+      const project = await this.projectModel.findById(id).lean()
+
+      if (!project) {
+        throw new Error(`Project with ID ${id} not found`)
+      }
+
+      return project
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Core function to get a specific project (returns raw data)
+   */
+  async _readMainProject(fastify: PluginFastifyInstance): Promise<ProjectType> {
+    try {
+      const projects = await this.projectModel.find({ isDefault: true }).lean()
+
+      if (!projects.length) {
+        throw new Error(`No main project found. This is a crucial error!`)
+      }
+
+      return projects[0]
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Get a specific project with payload wrapping
+   */
+  async readProject(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+  ): Promise<ClientPayload<ProjectType[]>> {
+    const project = await this._readProject(fastify, id)
+
+    return createProjectPayload(fastify, [project], requestData)
+  }
+
+  /**
+   * Core function to update an existing project (returns raw data)
+   */
+  async _updateProject(
+    fastify: PluginFastifyInstance,
+    id: string,
+    projectBody: Partial<ProjectUpdate>,
+    userId: string,
+  ): Promise<{ updated: ProjectType; original: ProjectType }> {
+    try {
+      const originalProject = await this.projectModel.findById(id)
+
+      if (!originalProject) {
+        throw new Error(`Project with ID ${id} not found`)
+      }
+
+      // Remove protected fields
+      delete projectBody._id
+      delete projectBody.account
+
+      const updatedProject = await this.projectModel
+        .findByIdAndUpdate(
+          id,
+          { ...projectBody, updatedBy: userId },
+          { new: true },
+        )
+        .lean()
+
+      if (!updatedProject) {
+        throw new Error(`Failed to update project with ID ${id}`)
+      }
+
+      fastify.log.info(`[API] Updated project #${updatedProject._id}`)
+
+      return {
+        updated: updatedProject,
+        original: originalProject.toObject
+          ? originalProject.toObject()
+          : originalProject,
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Update an existing project with payload wrapping and event emission
+   */
+  async updateProject(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+    projectBody: Partial<ProjectUpdate>,
+    userId: string,
+  ): Promise<ClientPayload<ProjectType[]>> {
+    const { updated, original } = await this._updateProject(
+      fastify,
+      id,
+      projectBody,
+      userId,
+    )
+
+    const payload = await createProjectPayload(fastify, [updated], requestData)
+
+    payload.body.prevVersion = original
+
+    if (requestData.broadcast) {
+      fastify.emit("projectUpdated", payload)
+    }
+
+    return payload
+  }
+
+  /**
+   * Core function to soft delete a project (returns raw data)
+   */
+  async _removeProject(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<ProjectType> {
+    try {
+      const project = await this.projectModel
+        .findByIdAndUpdate(id, { isDeleted: true }, { new: true })
+        .lean()
+
+      if (!project) {
+        throw new Error(`Project with ID ${id} not found`)
+      }
+
+      return project
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Soft delete a project with payload wrapping and event emission
+   */
+  async removeProject(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+  ): Promise<ClientPayload<ProjectType[]>> {
+    const project = await this._removeProject(fastify, id)
+
+    const payload = await createProjectPayload(fastify, [project], {
+      ...requestData,
+      type: "dataDelete",
+    })
+
+    payload.body.deleted = [project._id]
+    fastify.emit("projectDeleted", payload)
+
+    return payload
+  }
+
+  /**
+   * Core function to hard delete a project (returns raw data)
+   */
+  async _hardDeleteProject(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<ProjectType> {
+    try {
+      const project = await this.projectModel.findOne({
+        _id: id,
+        isDeleted: true,
+      })
+
+      if (!project) {
+        throw new Error(
+          `Project with ID ${id} not found or not marked for deletion`,
+        )
+      }
+
+      await this.projectModel.deleteOne({ _id: id })
+
+      return project.toObject ? project.toObject() : project
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Hard delete a project with payload wrapping and event emission
+   */
+  async hardDeleteProject(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+  ): Promise<ClientPayload<ProjectType[]>> {
+    const project = await this._hardDeleteProject(fastify, id)
+
+    const payload = await createProjectPayload(fastify, [project], {
+      ...requestData,
+      type: "dataHardDeleted",
+    })
+
+    payload.body.deleted = [project._id]
+    fastify.emit("projectHardDeleted", payload)
+
+    return payload
+  }
+}
+
+export const createProjectService = (model: Model<ProjectType>) =>
+  new ProjectService(model)

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

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