@raclettejs/core 0.1.17 → 0.1.19

package/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.19] - 12.12.2025 <a href="https://gitlab.com/raclettejs/core/-/compare/v0.1.18...v0.1.19" target="_blank" rel="noopener"><b>Overview of all changes</b></a>
+
+### Added
+
+- Global: added bulk import to interactionLinks, compositions and tags
+
+## [0.1.18] - 05.12.2025 <a href="https://gitlab.com/raclettejs/core/-/compare/v0.1.17...v0.1.18" target="_blank" rel="noopener"><b>Overview of all changes</b></a>
+
+### Changed
+
+- Backend: project data type deletion routes temporarily disabled. Will be reenabled soon
+- Frontend: updated dependencies
+
+### Added
+
+- Frontend: usermenu - added alternate render mode for inline composition if no trigger id/title is set
+- Frontend: Appbar can now house interactionLinks and inline compositions
+- Frontend: appbar can now launch compositions in a floating window
+- Backend: added restore endpoints for tag/user/composition/interactionLink
+- Frontend: Token expiry will now redirect automatically to login. Last location during auth loss will be used for redirect later
+- Frontend: Simple search input can now receive custom label and uses debounce before model update
+- Frontend: PageNavigation can now rail
+- Backend: Project dataType can now hold config values
+- Global: Added new Tagtype "event"
+
+### Fixed
+
+- Backend: isDeleted handling in getAll routes. isDeleted needs to be explicitly true to see deleted entries
+- Backend: TTL for auth token is not derived from raclette.config
+
 ## [0.1.17] - 06.11.2025 <a href="https://gitlab.com/raclettejs/core/-/compare/v0.1.15...v0.1.17" target="_blank" rel="noopener"><b>Overview of all changes</b></a>
 
 ### Fixed
@@ -14,7 +44,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Frontend: axios Delete handling
 - Frontend: retrieval of deleted compositions/interactionLinks during socket join
 - Frontend: notifications for delete events now show name
--
 
 ### Added
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raclettejs/core",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "racletteJS core package",
   "repository": "https://gitlab.com/raclettejs/core",
   "author": "Pacifico Digital Explorations GmbH <info@raclettejs.com>",
@@ -69,7 +69,7 @@
   },
   "devDependencies": {
     "@eslint/js": "9.35.0",
-    "@raclettejs/types": "^0.1.17",
+    "@raclettejs/types": "0.1.19",
     "@types/fs-extra": "11.0.4",
     "@types/js-yaml": "4.0.9",
     "@types/node": "24.5.1",

package/services/backend/package.json

@@ -30,7 +30,7 @@
     "@fastify/sensible": "6.0.3",
     "@sinclair/typebox": "0.34.41",
     "@types/vary": "1.1.3",
-    "axios": "1.12.2",
+    "axios": "1.13.2",
     "bcrypt": "6.0.0",
     "copyfiles": "2.4.1",
     "fastify": "5.6.0",
@@ -62,4 +62,4 @@
     "typescript": "5.9.2",
     "typescript-eslint": "8.44.0"
   }
-}
+}

package/services/backend/src/core/config/configService.ts

@@ -13,6 +13,7 @@ type RacletteBackendConfig = {
   plugins?: string[]
   global?: {
     requireAuthentication?: boolean
+    authTokenExpiryDays?: number
   }
   additionalPluginPaths?: string[]
 }
@@ -130,6 +131,9 @@ export class ConfigService {
   public isAuthRequired(): boolean {
     return this.config?.global?.requireAuthentication ?? true
   }
+  public getAuthTokenExpiryDays(): number {
+    return this.config?.global?.authTokenExpiryDays ?? 30
+  }
   public isAdminTagRequired(): boolean {
     return this.config?.onlyAllowLoginWithAdminTag ?? false
   }

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

@@ -97,6 +97,8 @@ export class CompositionService {
     filters: Record<string, any> = {},
   ): Promise<CompositionType[]> {
     try {
+      if (filters.isDeleted !== true && filters.isDeleted !== "true")
+        filters.isDeleted = false
       return await this.compositionModel
         .find({
           ...filters,
@@ -335,6 +337,90 @@ export class CompositionService {
     payload.body.deleted = [composition._id]
     fastify.emit("compositionHardDeleted", payload)
 
+    return payload
+  }
+  /**
+   * Core function to create multiple compositions (returns raw data)
+   */
+  async _createCompositions(
+    fastify: PluginFastifyInstance,
+    compositionBodies: CompositionBody[],
+    userId: string,
+  ): Promise<CompositionType[]> {
+    try {
+      const compositionsToCreate: CompositionBody[] = []
+
+      // Validate and prepare all compositions
+      for (const compositionBody of compositionBodies) {
+        if (compositionBody._id) {
+          const uuidValid = validate(compositionBody._id)
+
+          if (!uuidValid) {
+            throw new Error(
+              `Invalid ID - not a valid uuid v4: ${compositionBody._id}`,
+            )
+          }
+
+          const duplicate = await this.compositionModel.findOne({
+            _id: compositionBody._id,
+          })
+
+          if (duplicate) {
+            throw new Error(
+              `An entry with this id already exists: ${compositionBody._id}`,
+            )
+          }
+        } else {
+          compositionBody._id = uuidv4()
+        }
+
+        compositionsToCreate.push({
+          ...compositionBody,
+          author: userId,
+          lastEditor: userId,
+        })
+      }
+
+      // Bulk insert
+      const compositions =
+        await this.compositionModel.insertMany(compositionsToCreate)
+
+      fastify.log.info(
+        `[API] Created ${compositions.length} compositions in bulk`,
+      )
+
+      return compositions.map((comp) =>
+        comp.toObject ? comp.toObject() : comp,
+      )
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create multiple compositions with payload wrapping and event emission
+   */
+  async createCompositions(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    compositionBodies: CompositionBody[],
+    userId: string,
+  ): Promise<FrontendPayload<CompositionType[]>> {
+    const compositions = await this._createCompositions(
+      fastify,
+      compositionBodies,
+      userId,
+    )
+
+    const payload = await createCompositionPayload(
+      fastify,
+      compositions,
+      requestData,
+    )
+
+    fastify.emit("compositionsCreated", payload)
+
     return payload
   }
 }

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

@@ -4,13 +4,17 @@ 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 postBulk from "./route.composition.post.bulk"
 import remove from "./route.composition.remove"
+import restore from "./route.composition.restore"
 
 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.patch("/composition/:_id/restore", restore(fastify))
   await fastify.post("/composition", post(fastify))
+  await fastify.post("/composition/bulk", postBulk(fastify))
   await fastify.delete("/composition/:_id", remove(fastify))
   await fastify.delete("/composition/:_id/hard", hardDelete(fastify))
 }

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

@@ -0,0 +1,58 @@
+import type { CompositionBody } from "../composition.service"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { compositionCreateSchema } from "../composition.schema"
+
+export default (fastify: PluginFastifyInstance) => {
+  const compositionService = fastify.custom.compositionService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Body: CompositionBody[]
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      // Validate that body is an array
+      if (!Array.isArray(req.body)) {
+        return reply.badRequest("Request body must be an array of compositions")
+      }
+
+      // Validate that array is not empty
+      if (req.body.length === 0) {
+        return reply.badRequest("Request body cannot be an empty array")
+      }
+
+      const payload = await compositionService.createCompositions(
+        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],
+    config: {
+      type: "dataCreate",
+      broadcastChannels: ["compositionsCreated"],
+    },
+    schema: {
+      summary: "Create multiple compositions in bulk",
+      tags: ["core/composition"],
+      body: {
+        type: "array",
+        items: compositionCreateSchema,
+        minItems: 1,
+      },
+    },
+  }
+}

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

@@ -0,0 +1,55 @@
+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(),
+})
+type Params = Static<typeof ParamsSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const compositionService = fastify.custom.compositionService
+
+  const handler = async (
+    req: FastifyRequest<{ Params: Params }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      if (req.user.isAdmin) {
+        const { _id } = req.params
+
+        const payload = await compositionService.updateComposition(
+          fastify,
+          req.requestParams,
+          _id,
+          { isDeleted: false },
+          req.user._id,
+        )
+
+        return payload
+      } else {
+        throw new ForbiddenError("Only admins can restore this core datatype")
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataRestore",
+      broadcastChannels: ["compositionRestored"],
+    },
+    schema: {
+      summary: "restore a composition by id",
+      description: "Restore a composition",
+      tags: ["core/composition"],
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -100,6 +100,8 @@ export class InteractionLinkService {
     filters: Record<string, any> = {},
   ): Promise<InteractionLinkType[]> {
     try {
+      if (filters.isDeleted !== true && filters.isDeleted !== "true")
+        filters.isDeleted = false
       return await this.interactionLinkModel
         .find({
           ...filters,
@@ -128,16 +130,16 @@ export class InteractionLinkService {
   }
 
   /**
-   * Core function to get interaction links by composition ID (returns raw data)
+   * Core function to get interaction links by interactionLink ID (returns raw data)
    */
-  async _readInteractionLinksByComposition(
+  async _readInteractionLinksByInteractionLink(
     fastify: PluginFastifyInstance,
-    compositionId: string,
+    interactionLinkId: string,
   ): Promise<InteractionLinkType[]> {
     try {
       return await this.interactionLinkModel
         .find({
-          composition: compositionId,
+          interactionLink: interactionLinkId,
           isDeleted: false,
         })
         .lean()
@@ -148,16 +150,16 @@ export class InteractionLinkService {
   }
 
   /**
-   * Get interaction links by composition ID with payload wrapping
+   * Get interaction links by interactionLink ID with payload wrapping
    */
-  async readInteractionLinksByComposition(
+  async readInteractionLinksByInteractionLink(
     fastify: PluginFastifyInstance,
     requestData: FrontendPayloadRequestData,
-    compositionId: string,
+    interactionLinkId: string,
   ): Promise<FrontendPayload<InteractionLinkType[]>> {
-    const interactionLinks = await this._readInteractionLinksByComposition(
+    const interactionLinks = await this._readInteractionLinksByInteractionLink(
       fastify,
-      compositionId,
+      interactionLinkId,
     )
 
     return createInteractionLinkPayload(fastify, interactionLinks, requestData)
@@ -437,6 +439,91 @@ export class InteractionLinkService {
 
     return createInteractionLinkPayload(fastify, interactionLinks, requestData)
   }
+  /**
+   * Core function to create multiple interactionLinks (returns raw data)
+   */
+  async _createInteractionLinks(
+    fastify: PluginFastifyInstance,
+    interactionLinkBodies: InteractionLinkBody[],
+    userId: string,
+  ): Promise<InteractionLinkType[]> {
+    try {
+      const interactionLinksToCreate: InteractionLinkBody[] = []
+
+      // Validate and prepare all interactionLinks
+      for (const interactionLinkBody of interactionLinkBodies) {
+        if (interactionLinkBody._id) {
+          const uuidValid = validate(interactionLinkBody._id)
+
+          if (!uuidValid) {
+            throw new Error(
+              `Invalid ID - not a valid uuid v4: ${interactionLinkBody._id}`,
+            )
+          }
+
+          const duplicate = await this.interactionLinkModel.findOne({
+            _id: interactionLinkBody._id,
+          })
+
+          if (duplicate) {
+            throw new Error(
+              `An entry with this id already exists: ${interactionLinkBody._id}`,
+            )
+          }
+        } else {
+          interactionLinkBody._id = uuidv4()
+        }
+
+        interactionLinksToCreate.push({
+          ...interactionLinkBody,
+          author: userId,
+          lastEditor: userId,
+        })
+      }
+
+      // Bulk insert
+      const interactionLinks = await this.interactionLinkModel.insertMany(
+        interactionLinksToCreate,
+      )
+
+      fastify.log.info(
+        `[API] Created ${interactionLinks.length} interactionLinks in bulk`,
+      )
+
+      return interactionLinks.map((comp) =>
+        comp.toObject ? comp.toObject() : comp,
+      )
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create multiple interactionLinks with payload wrapping and event emission
+   */
+  async createInteractionLinks(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    interactionLinkBodies: InteractionLinkBody[],
+    userId: string,
+  ): Promise<FrontendPayload<InteractionLinkType[]>> {
+    const interactionLinks = await this._createInteractionLinks(
+      fastify,
+      interactionLinkBodies,
+      userId,
+    )
+
+    const payload = await createInteractionLinkPayload(
+      fastify,
+      interactionLinks,
+      requestData,
+    )
+
+    fastify.emit("interactionLinksCreated", payload)
+
+    return payload
+  }
 }
 
 export const createInteractionLinkService = (

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

@@ -4,13 +4,17 @@ import getAll from "./route.interactionLink.getAll"
 import hardDelete from "./route.interactionLink.hardDelete"
 import patch from "./route.interactionLink.patch"
 import post from "./route.interactionLink.post"
+import postBulk from "./route.interactionLink.post.bulk"
 import remove from "./route.interactionLink.remove"
+import restore from "./route.interactionLink.restore"
 
 const registerRoutes = async (fastify: PluginFastifyInstance) => {
   await fastify.get("/interactionLink/all", getAll(fastify))
   await fastify.get("/interactionLink/:_id", get(fastify))
   await fastify.patch("/interactionLink/:_id", patch(fastify))
+  await fastify.patch("/interactionLink/:_id/restore", restore(fastify))
   await fastify.post("/interactionLink", post(fastify))
+  await fastify.post("/interactionLink/bulk", postBulk(fastify))
   await fastify.delete("/interactionLink/:_id", remove(fastify))
   await fastify.delete("/interactionLink/:_id/hard", hardDelete(fastify))
 }

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

@@ -0,0 +1,60 @@
+import type { InteractionLinkBody } from "../interactionLink.service"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { interactionLinkCreateSchema } from "../interactionLink.schema"
+
+export default (fastify: PluginFastifyInstance) => {
+  const interactionLinkService = fastify.custom.interactionLinkService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Body: InteractionLinkBody[]
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      // Validate that body is an array
+      if (!Array.isArray(req.body)) {
+        return reply.badRequest(
+          "Request body must be an array of interactionLinks",
+        )
+      }
+
+      // Validate that array is not empty
+      if (req.body.length === 0) {
+        return reply.badRequest("Request body cannot be an empty array")
+      }
+
+      const payload = await interactionLinkService.createInteractionLinks(
+        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],
+    config: {
+      type: "dataCreate",
+      broadcastChannels: ["interactionLinksCreated"],
+    },
+    schema: {
+      summary: "Create multiple interactionLinks in bulk",
+      tags: ["core/interactionLink"],
+      body: {
+        type: "array",
+        items: interactionLinkCreateSchema,
+        minItems: 1,
+      },
+    },
+  }
+}

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

@@ -0,0 +1,55 @@
+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(),
+})
+type Params = Static<typeof ParamsSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const interactionLinkService = fastify.custom.interactionLinkService
+
+  const handler = async (
+    req: FastifyRequest<{ Params: Params }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      if (req.user.isAdmin) {
+        const { _id } = req.params
+
+        const payload = await interactionLinkService.updateInteractionLink(
+          fastify,
+          req.requestParams,
+          _id,
+          { isDeleted: false },
+          req.user._id,
+        )
+
+        return payload
+      } else {
+        throw new ForbiddenError("Only admins can restore this core datatype")
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataRestore",
+      broadcastChannels: ["interactionLinkRestored"],
+    },
+    schema: {
+      summary: "restore a interactionLink by id",
+      description: "Restore a interactionLink",
+      tags: ["core/interactionLink"],
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -34,6 +34,23 @@ const projectSchema = new Schema(
 
     // soft delete
     isDeleted: { type: Boolean, default: false },
+    config: {
+      type: {
+        tags: {
+          type: [Schema.Types.String],
+          ref: "raclette__core-tag",
+          default: [],
+        },
+        railPageNavigation: {
+          type: Boolean,
+          default: false,
+        },
+      },
+      default: () => ({
+        tags: [],
+        railPageNavigation: false,
+      }),
+    },
   },
   { timestamps: true },
 )

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

@@ -2,16 +2,28 @@ 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 projectConfigSchema = Type.Optional(
+  Type.Object(
+    {
+      tags: Type.Array(Type.String(), { default: [] }),
+      railPageNavigation: Type.Boolean({ default: false }),
+    },
+    {
+      $id: "#project/config",
+      title: "core/project-config",
+    },
+  ),
+)
 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 })),
+  config: projectConfigSchema,
 }
 
 /**
@@ -51,11 +63,7 @@ export const projectCreateSchema = Type.Object(
 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()),
+    ...baseProjectSchema,
   },
   {
     $id: "#project/update",
@@ -104,4 +112,8 @@ export const registerSchemas = (fastify: PluginFastifyInstance) => {
     schema: projectUpdateSchema,
     name: "ProjectUpdate",
   })
+  fastify.registerSchema({
+    schema: projectConfigSchema,
+    name: "ProjectConfig",
+  })
 }