@raclettejs/core 0.1.17 → 0.1.18

package/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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 +38,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.18",
   "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.18",
     "@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,

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

@@ -5,11 +5,13 @@ import hardDelete from "./route.composition.hardDelete"
 import patch from "./route.composition.patch"
 import post from "./route.composition.post"
 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.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.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,

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

@@ -5,11 +5,13 @@ import hardDelete from "./route.interactionLink.hardDelete"
 import patch from "./route.interactionLink.patch"
 import post from "./route.interactionLink.post"
 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.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.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",
+  })
 }

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

@@ -1,10 +1,10 @@
 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"
+//import hardDelete from "./route.project.hardDelete"
+//import remove from "./route.project.remove"
 
 const registerRoutes = async (fastify: PluginFastifyInstance) => {
   await fastify.get("/project/all", getAll(fastify))
@@ -12,9 +12,9 @@ const registerRoutes = async (fastify: PluginFastifyInstance) => {
 
   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))
+  // TODO reenable once we have deletion concept and space datatype implemented
+  //await fastify.delete("/project/:_id", remove(fastify))
+  //await fastify.delete("/project/:_id/hard", hardDelete(fastify))
 }
 
 export default registerRoutes

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

@@ -5,11 +5,13 @@ import hardDelete from "./route.tag.hardDelete"
 import patch from "./route.tag.patch"
 import post from "./route.tag.post"
 import remove from "./route.tag.remove"
+import restore from "./route.tag.restore"
 
 const registerRoutes = async (fastify: PluginFastifyInstance) => {
   await fastify.get("/tag/all", getAll(fastify))
   await fastify.get("/tag/:_id", get(fastify))
   await fastify.patch("/tag/:_id", patch(fastify))
+  await fastify.patch("/tag/:_id/restore", restore(fastify))
   await fastify.post("/tag/:project/:_id", post(fastify))
   await fastify.delete("/tag/:_id", remove(fastify))
   await fastify.delete("/tag/:_id/hard", hardDelete(fastify))

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/tag/routes/route.tag.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 tagService = fastify.custom.tagService
+
+  const handler = async (
+    req: FastifyRequest<{ Params: Params }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      if (req.user.isAdmin) {
+        const { _id } = req.params
+
+        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")
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataRestore",
+      broadcastChannels: ["tagRestored"],
+    },
+    schema: {
+      summary: "restore a tag by id",
+      description: "Restore a tag",
+      tags: ["core/tag"],
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -131,6 +131,8 @@ export class TagService {
     options: QueryOptions = {},
   ): Promise<TagType[]> {
     try {
+      if (filter.isDeleted !== true && filter.isDeleted !== "true")
+        filter.isDeleted = false
       // Start building the query
       let query = this.tagModel.find(filter)
 

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

@@ -6,11 +6,13 @@ import patchLastProject from "./route.user.patchLastProject"
 import post from "./route.user.post"
 import remove from "./route.user.remove"
 import hardDelete from "./route.user.hardDelete"
+import restore from "./route.user.restore"
 
 const registerRoutes = async (fastify: PluginFastifyInstance) => {
   await fastify.get("/user/all", getAll(fastify))
   await fastify.get("/user/:_id", get(fastify))
   await fastify.patch("/user/:_id", patch(fastify))
+  await fastify.patch("/user/:_id/restore", restore(fastify))
   await fastify.post("/user", post(fastify))
   await fastify.delete("/user/:_id", remove(fastify))
   await fastify.delete("/user/:_id/hard", hardDelete(fastify))

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.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 userService = fastify.custom.userService
+
+  const handler = async (
+    req: FastifyRequest<{ Params: Params }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      if (req.user.isAdmin) {
+        const { _id } = req.params
+
+        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")
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataRestore",
+      broadcastChannels: ["userRestored"],
+    },
+    schema: {
+      summary: "restore a user by id",
+      description: "Restore a user",
+      tags: ["core/user"],
+      params: ParamsSchema,
+    },
+  }
+}

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

@@ -135,6 +135,7 @@ export class UserService {
     options: QueryOptions = {},
   ): Promise<UserType[]> {
     try {
+      if (filter.isDeleted !== true && filter.isDeleted !=='true') filter.isDeleted = false
       // Start building the query
       let query = this.userModel.find(filter)
 

package/services/backend/src/domains/system/routes/route.user.login.ts

@@ -1,5 +1,6 @@
 import type { UserDoc } from "@/corePlugins/raclette__core/backend/datatypes/user/user.schema"
 import type { Static } from "@sinclair/typebox"
+import configService from "@/core/config/configService"
 import type { FastifyRequest, FastifyReply, FastifyInstance } from "fastify"
 import { Type } from "@sinclair/typebox"
 import { toPublicUser } from "@/corePlugins/raclette__core/backend/datatypes/user/user.schema"
@@ -183,9 +184,10 @@ export default (fastify: FastifyInstance) => {
         deviceId: deviceId || request.ip,
         iat: Math.floor(Date.now() / 1000),
       }
-
+      // Set the expiry time/TTL for the auth token to the configured value
+      const expiryDays = configService.getAuthTokenExpiryDays()
       const token = fastify.jwt.sign(tokenPayload, {
-        expiresIn: "24h",
+        expiresIn: `${expiryDays}d`,
       })
       const decoded = fastify.jwt.decode(token)
 

package/services/backend/src/shared/types/core/ProjectUpdate.types.ts

@@ -11,6 +11,7 @@ export type ProjectUpdate = {
   title?: string
   account?: string
   tags?: string[]
+  config: object
   description?: string
   isDefault?: boolean
 }

package/services/backend/src/shared/types/dataTypes/tags.ts

@@ -5,6 +5,7 @@ export const frontendTagTypes = [
   "user",
   "project",
   "category",
+  "event"
 ] as const
 
 export const tag = {

package/services/frontend/package.json

@@ -21,9 +21,9 @@
     "@sinclair/typebox": "0.34.41",
     "@tailwindcss/vite": "4.1.13",
     "@tsconfig/node20": "20.1.6",
-    "@vueuse/core": "13.9.0",
-    "@vueuse/rxjs": "13.9.0",
-    "axios": "1.12.2",
+    "@vueuse/core": "14.1.0",
+    "@vueuse/rxjs": "14.1.0",
+    "axios": "1.13.2",
     "date-fns": "4.1.0",
     "esm": "3.x",
     "interactjs": "1.10.27",
@@ -35,10 +35,10 @@
     "socket.io-client": "4.x",
     "tailwindcss": "4.1.13",
     "uuid": "13.0.0",
-    "vue": "3.5.21",
-    "vue-i18n": "11.1.12",
-    "vue-router": "4.5.1",
-    "vuetify": "3.10.2"
+    "vue": "3.5.25",
+    "vue-i18n": "11.2.2",
+    "vue-router": "4.6.3",
+    "vuetify": "3.11.2"
   },
   "devDependencies": {
     "@types/node": "24.5.1",
@@ -58,4 +58,4 @@
     "vue-eslint-parser": "10.2.0",
     "vue-tsc": "3.0.7"
   }
-}
+}

package/services/frontend/src/core/lib/configService.ts

@@ -71,7 +71,7 @@ export class ConfigService {
     return this.config.plugins || []
   }
   public getAuthTokenExpiryDays(): number {
-    return this.config.global?.authTokenExpiryDays ?? 7
+    return this.config.global?.authTokenExpiryDays ?? 30
   }
   public getAdditonalPluginPaths(): string[] {
     return this.config.additionalPluginPaths?.map((e) => `${e}`) || []

package/services/frontend/src/core/lib/data/fetchDataHandler.ts

@@ -2,6 +2,7 @@ import log from "@racletteCore/lib/logger"
 import {
   promisifyActionResolve,
   markDataAsModified,
+  handleErrors,
 } from "@racletteCore/lib/dataHelper"
 import { $api, $store } from "@racletteCore"
 import {
@@ -203,7 +204,6 @@ const finishRemoteQuery = (actionIdentifier, result = {}, params, options) => {
 
   return itemDispatcher(actionIdentifier, resultObj, true)
 }
-
 // Unified remote data handler for both GET and POST
 const handleRemoteRequest = async (
   actionIdentifier,
@@ -237,28 +237,8 @@ const handleRemoteRequest = async (
   try {
     const response =
       method === "GET"
-        ? await $api.axios.get(target, config).catch((e) => {
-            if (e.name !== "CanceledError") {
-              $eventbus.emit("ui/addToSnackbar", {
-                message: e.response?.data?.message || "error",
-                color: "error",
-              })
-              throw e
-            }
-            log.api("axios/get/error", e)
-            return {}
-          })
-        : await $api.axios.post(target, params, config).catch((e) => {
-            if (e.name !== "CanceledError") {
-              $eventbus.emit("ui/addToSnackbar", {
-                message: e.response?.data?.message || "error",
-                color: "error",
-              })
-              throw e
-            }
-            log.api("axios/post/error", e)
-            return {}
-          })
+        ? await $api.axios.get(target, config).catch(handleErrors)
+        : await $api.axios.post(target, params, config).catch(handleErrors)
 
     return {
       response,