@raclettejs/core 0.0.1

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

@@ -0,0 +1,49 @@
+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 tagService = fastify.custom.tagService
+
+  const handler = async (
+    req: FastifyRequest<{ Params: Params }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      const { _id } = req.params
+
+      const payloadWithTag = await tagService.removeTag(
+        fastify,
+        req.requestParams,
+        _id,
+      )
+
+      return payloadWithTag
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataUpdate",
+      broadcastChannels: ["tagDeleted"],
+    },
+    schema: {
+      summary: "Disable a tag by id",
+      description:
+        "Soft delete a tag. The entry still exists but is not used anymore",
+      tags: ["core/tag"],
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -0,0 +1,87 @@
+import mongoose from "mongoose"
+import { v4 as uuidv4 } from "uuid"
+import { tagTypes } from "@shared/types/dataTypes/tags"
+import { PluginFastifyInstance } from "types"
+const { Schema } = mongoose
+
+export const MODEL_BASENAME = "tag"
+
+const tagSchema = new Schema(
+  {
+    _id: {
+      type: String,
+      default: () => uuidv4(),
+      required: true,
+    },
+
+    /* tags can belong to a project or be global */
+    project: {
+      type: Schema.Types.String,
+      ref: "raclette__core-project",
+      required: false,
+    },
+
+    /* the actual tag content */
+    title: {
+      type: String,
+      default: null,
+      maxLength: 200,
+    },
+    /* tags, note that label and ticket have to belong to the same project */
+    tags: {
+      type: [Schema.Types.String],
+      ref: "raclette__core-tag",
+      default: [],
+    },
+    /* hex color code */
+    color: {
+      type: String,
+      default: "#CCCCCC",
+      validate: {
+        validator: (value: string) => {
+          const hexstring = /^#([0-9a-f]{3}){1,2}$/i
+          return hexstring.test(value)
+        },
+        message: (props: any) => `${props.value} is not a valid hex value!`,
+      },
+    },
+
+    owner: {
+      type: Schema.Types.String,
+      ref: "raclette__core-user",
+      default: null,
+    },
+
+    updatedBy: {
+      type: Schema.Types.String,
+      ref: "raclette__core-user",
+      default: null,
+    },
+
+    /* status, milestone, content, system */
+    type: {
+      type: String,
+      maxLength: 50,
+      default: "content",
+      enum: tagTypes,
+      required: true,
+    },
+    order: {
+      type: Number,
+      default: 0,
+    },
+    /* we want to discriminate project tags from simple user tags */
+    locked: {
+      type: Boolean,
+      default: false,
+    },
+
+    /* soft delete */
+    isDeleted: { type: Boolean, default: false },
+  },
+  { timestamps: true },
+)
+
+export const createModels = (fastify: PluginFastifyInstance) => {
+  return fastify.createModel(MODEL_BASENAME, tagSchema)
+}

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

@@ -0,0 +1,117 @@
+import type { Static } from "@sinclair/typebox"
+import type { Document } from "mongoose"
+import type { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+import { tagTypes } from "@shared/types/dataTypes/tags"
+
+/**
+ * Base Tag Schema - Fields common to all operations
+ */
+const baseTagSchema = {
+  project: Type.Optional(Type.String()),
+  title: Type.Optional(Type.String({ maxLength: 200, default: null })),
+  tags: Type.Optional(Type.Array(Type.String(), { default: [] })),
+  locked: Type.Optional(Type.Boolean({ default: false })),
+  color: Type.Optional(
+    Type.String({ pattern: "^#([0-9a-fA-F]{3}){1,2}$", default: "#CCCCCC" }),
+  ),
+  type: Type.Optional(
+    Type.String({ enum: tagTypes, maxLength: 50, default: "system" }),
+  ),
+}
+
+/**
+ * Full Tag Schema - Used for response serialization and database model
+ */
+export const tagSchema = Type.Object(
+  {
+    _id: Type.String(),
+    ...baseTagSchema,
+    owner: Type.String(),
+    order: Type.Optional(Type.Number({ default: 0 })),
+    isDeleted: Type.Boolean({ default: false }),
+    createdAt: Type.String({ format: "date-time" }),
+    updatedAt: Type.String({ format: "date-time" }),
+  },
+  {
+    $id: "#tag/base",
+    title: "core/tag",
+  },
+)
+
+/**
+ * Tag Create Schema - For POST operations
+ */
+export const tagCreateSchema = Type.Object(
+  {
+    _id: Type.Optional(Type.String()),
+    ...baseTagSchema,
+  },
+  {
+    $id: "#tag/create",
+    title: "core/tag-create",
+  },
+)
+
+/**
+ * Tag Update Schema - For PATCH operations
+ */
+export const tagUpdateSchema = Type.Object(
+  {
+    project: Type.Optional(Type.String()),
+    title: Type.Optional(Type.String({ maxLength: 200 })),
+    tags: Type.Optional(Type.Array(Type.String())),
+    color: Type.Optional(Type.String({ pattern: "^#([0-9a-fA-F]{3}){1,2}$" })),
+    type: Type.Optional(Type.String({ enum: tagTypes, maxLength: 50 })),
+    owner: Type.Optional(Type.String()),
+    order: Type.Optional(Type.Number()),
+    locked: Type.Optional(Type.Boolean()),
+  },
+  {
+    $id: "#tag/update",
+    title: "core/tag-update",
+  },
+)
+
+/**
+ * Type Utilities
+ */
+
+type DateTimeFields = {
+  createdAt: Date
+  updatedAt: Date
+}
+
+type RawTag = Static<typeof tagSchema>
+export type Tag = Omit<RawTag, keyof DateTimeFields> & DateTimeFields
+
+type RawTagCreate = Static<typeof tagCreateSchema>
+export type TagCreate = RawTagCreate
+
+type RawTagUpdate = Static<typeof tagUpdateSchema>
+export type TagUpdate = RawTagUpdate
+
+export interface TagDoc extends Document, Tag {
+  _id: string
+}
+export type AnyTag = Tag | TagDoc
+
+/**
+ * Register Schema/Type Generation for Shared Folder
+ */
+export const registerSchemas = (fastify: PluginFastifyInstance) => {
+  fastify.registerSchema({
+    schema: tagSchema,
+    name: "Tag",
+  })
+
+  fastify.registerSchema({
+    schema: tagCreateSchema,
+    name: "TagCreate",
+  })
+
+  fastify.registerSchema({
+    schema: tagUpdateSchema,
+    name: "TagUpdate",
+  })
+}

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

@@ -0,0 +1,346 @@
+import type { TagCreate, Tag as TagType, TagUpdate } from "./tag.schema"
+import type {
+  ClientPayload,
+  ClientPayloadRequestData,
+} from "@c/payload/payloadTypes"
+import type { QueryOptions } from "@m/database/providers/mongodb/service"
+import type { PluginFastifyInstance } from "types"
+import { v4 as uuidv4, validate } from "uuid"
+import { createTagPayload } from "./helpers/payload"
+import type { Model } from "mongoose"
+
+export class TagService {
+  private tagModel: Model<TagType>
+
+  constructor(model: Model<TagType>) {
+    this.tagModel = model
+  }
+  /**
+   * Core function to create a new tag (returns raw data)
+   */
+  async _createTag(
+    fastify: PluginFastifyInstance,
+    tagBody: TagCreate,
+  ): Promise<TagType> {
+    try {
+      if (tagBody._id) {
+        const uuidValid = validate(tagBody._id)
+
+        if (!uuidValid) {
+          throw new Error("Invalid ID - not a valid uuid v4")
+        }
+
+        const duplicate = await this.tagModel.findById(tagBody._id)
+
+        if (duplicate) {
+          throw new Error("An entry with this id already exists")
+        }
+      } else {
+        tagBody._id = uuidv4()
+      }
+
+      const tag = new this.tagModel(tagBody)
+
+      await tag.save()
+      fastify.log.info(
+        `[API] Created tag #${tag._id} in project #${tag.project}`,
+      )
+
+      return tag.toObject ? tag.toObject() : tag
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create a new tag with payload wrapping and event emission
+   */
+  async createTag(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    tagBody: TagCreate,
+  ): Promise<ClientPayload<TagType[]>> {
+    const tag = await this._createTag(fastify, tagBody)
+
+    const payload = await createTagPayload(fastify, [tag], requestData)
+
+    fastify.emit("tagCreated", payload)
+
+    return payload
+  }
+
+  /**
+   * Core function to read a specific tag by ID (returns raw data)
+   */
+  async _readTag(fastify: PluginFastifyInstance, id: string): Promise<TagType> {
+    try {
+      const tag = await this.tagModel.findById(id).lean()
+
+      if (!tag) {
+        throw new Error(`Tag with ID ${id} not found`)
+      }
+
+      return tag
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Read a specific tag by ID with payload wrapping
+   */
+  async readTag(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+  ): Promise<ClientPayload<TagType[]>> {
+    const tag = await this._readTag(fastify, id)
+
+    return createTagPayload(fastify, [tag], requestData)
+  }
+
+  /**
+   * Core function to read tags by ID or filter parameters (returns raw data)
+   */
+  async _readTags(
+    fastify: PluginFastifyInstance,
+    filter: Record<string, any> = { isDeleted: false },
+    options: QueryOptions = {},
+  ): Promise<TagType[]> {
+    try {
+      // Start building the query
+      let query = this.tagModel.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 tags by ID or filter parameters with payload wrapping
+   */
+  async readTags(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    filter: { id?: string; projectId?: string; isDeleted?: boolean } = {
+      isDeleted: false,
+    },
+  ): Promise<ClientPayload<TagType[]>> {
+    try {
+      if (filter.id) {
+        // Get single tag
+        const tag = await this._readTag(fastify, filter.id)
+
+        return createTagPayload(fastify, [tag], requestData)
+      } else {
+        const tags = await this._readTags(fastify, filter)
+
+        return createTagPayload(fastify, tags, requestData)
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Core function to update an existing tag (returns raw data)
+   */
+  async _updateTag(
+    fastify: PluginFastifyInstance,
+    id: string,
+    tagBody: TagUpdate,
+    userId: string,
+  ): Promise<{ updated: TagType; original: TagType }> {
+    try {
+      const originalTag = await this.tagModel.findById(id)
+
+      if (!originalTag) {
+        throw new Error(`Tag with ID ${id} not found`)
+      }
+
+      const updatedTag = await this.tagModel.findByIdAndUpdate(
+        id,
+        { ...tagBody, updatedBy: userId },
+        { new: true },
+      )
+
+      if (!updatedTag) {
+        throw new Error(`Failed to update tag with ID ${id}`)
+      }
+
+      fastify.log.info(`[API] Updated tag #${updatedTag._id}`)
+
+      return {
+        updated: updatedTag.toObject ? updatedTag.toObject() : updatedTag,
+        original: originalTag.toObject ? originalTag.toObject() : originalTag,
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Update an existing tag with payload wrapping and event emission
+   */
+  async updateTag(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+    tagBody: TagUpdate,
+    userId: string,
+  ): Promise<ClientPayload<TagType[]>> {
+    const isLockedTag = await this.tagModel
+      .findOne({ _id: id, locked: true })
+      .lean()
+
+    if (isLockedTag) {
+      throw new Error(`Tag with ID ${id} is locked and can't be updated`)
+    }
+    const { updated, original } = await this._updateTag(
+      fastify,
+      id,
+      tagBody,
+      userId,
+    )
+
+    const payload = await createTagPayload(fastify, [updated], requestData)
+
+    payload.body.prevVersion = original
+
+    if (requestData.broadcast) {
+      fastify.emit("tagUpdated", payload)
+    }
+
+    return payload
+  }
+
+  /**
+   * Core function to soft delete a tag (returns raw data)
+   */
+  async _removeTag(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<TagType> {
+    try {
+      // TODO: Add an universal childCount check
+      const tag = await this.tagModel
+        .findByIdAndUpdate(id, { isDeleted: true }, { new: true })
+        .lean()
+
+      if (!tag) {
+        throw new Error(`Tag with ID ${id} not found`)
+      }
+
+      return tag
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Soft delete a tag with payload wrapping and event emission
+   */
+  async removeTag(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+  ): Promise<ClientPayload<TagType[]>> {
+    const isLockedTag = await this.tagModel
+      .findOne({ _id: id, locked: true })
+      .lean()
+    if (isLockedTag) {
+      throw new Error(`Tag with ID ${id} is locked and can't be deleted`)
+    }
+
+    const tag = await this._removeTag(fastify, id)
+
+    const payload = await createTagPayload(fastify, [tag], {
+      ...requestData,
+      type: "dataDelete",
+    })
+
+    payload.body.deleted = [tag._id]
+
+    fastify.emit("tagDeleted", payload)
+
+    return payload
+  }
+
+  /**
+   * Core function to hard delete a tag (returns raw data)
+   */
+  async _hardDeleteTag(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<TagType> {
+    try {
+      const tag = await this.tagModel.findOne({ _id: id, isDeleted: true })
+
+      if (!tag) {
+        throw new Error(
+          `Tag with ID ${id} not found or not marked for deletion`,
+        )
+      }
+
+      await this.tagModel.deleteOne({ _id: id })
+
+      return tag.toObject ? tag.toObject() : tag
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Hard delete a tag with payload wrapping and event emission
+   */
+  async hardDeleteTag(
+    fastify: PluginFastifyInstance,
+    requestData: ClientPayloadRequestData,
+    id: string,
+  ): Promise<ClientPayload<TagType[]>> {
+    const isLockedTag = await this.tagModel
+      .findOne({ _id: id, locked: true })
+      .lean()
+    if (isLockedTag) {
+      throw new Error(`Tag with ID ${id} is locked and can't be hard deleted`)
+    }
+    const tag = await this._hardDeleteTag(fastify, id)
+
+    const payload = await createTagPayload(fastify, [tag], {
+      ...requestData,
+      type: "dataHardDeleted",
+    })
+
+    payload.body.deleted = [tag._id]
+
+    fastify.emit("tagHardDeleted", payload)
+
+    return payload
+  }
+}
+
+export const createTagService = (model: Model<TagType>) => new TagService(model)

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

@@ -0,0 +1,39 @@
+import type { AnyUser } from "../user.schema"
+import type { ClientPayload } from "@c/payload/payloadTypes"
+import { PluginFastifyInstance } from "types"
+
+export const registerEvents = (fastify: PluginFastifyInstance) => {
+  /*
+   * user created
+   */
+  const created = async (payload: ClientPayload<AnyUser>) => {
+    fastify.eventbus.emit("broadcastDataUpdated", payload)
+    fastify.eventbus.emit("broadcastUserCreated", payload)
+    fastify.log.info(`[eventbus] user broadcast created ${payload.body.items}`)
+  }
+
+  /*
+   * user updated
+   */
+  const updated = async (payload: ClientPayload<AnyUser>) => {
+    fastify.eventbus.emit("broadcastDataUpdated", payload)
+    fastify.log.info(`[eventbus] user broadcast updated ${payload.body.items}`)
+  }
+
+  /*
+   * user deleted
+   */
+  const deleted = async (payload: ClientPayload<AnyUser>) => {
+    fastify.eventbus.emit("broadcastUserDeleted", payload)
+    fastify.log.info(`[eventbus] user broadcast deleted ${payload.body.items}`)
+  }
+
+  /**
+   * Register those functions for eventbus events
+   */
+  fastify.eventbus.on("coreUserCreated", created)
+  fastify.eventbus.on("coreUserUpdated", updated)
+  fastify.eventbus.on("coreUserDeleted", deleted)
+}
+
+export default registerEvents

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

@@ -0,0 +1,12 @@
+import type { PluginFastifyInstance } from "@raclettejs/core"
+
+export const registerCrud = (fastify: PluginFastifyInstance) => {
+  const userService = fastify.custom.userService
+
+  fastify.registerCrudHandlers("user", {
+    create: userService.createUser,
+    read: userService.readUser,
+    update: userService.updateUser,
+    delete: userService.removeUser,
+  })
+}

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

@@ -0,0 +1,20 @@
+import { type User, toPublicUser } from "../user.schema"
+import type { ClientPayloadRequestData, PluginFastifyInstance } from "types"
+
+export const registerPayload = (fastify: PluginFastifyInstance) => {
+  fastify.registerPayloadHandler<User>("user", {
+    type: "user",
+    displayName: (user: User) => `${user.firstname} ${user.lastname}`.trim(),
+    completion: (user: User) =>
+      `${user.firstname} ${user.lastname} ${user.email}`,
+
+    // Sanitization to remove sensitive data
+    sanitize: (user: User) => toPublicUser(user),
+  })
+}
+
+export const createUserPayload = async (
+  fastify: PluginFastifyInstance,
+  items: User[],
+  requestData: ClientPayloadRequestData,
+) => await fastify.createPayload("user", items, requestData)