@raclettejs/core 0.1.16 → 0.1.18

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

@@ -2,6 +2,7 @@ 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(),
@@ -16,15 +17,21 @@ export default (fastify: PluginFastifyInstance) => {
     reply: FastifyReply,
   ) => {
     try {
-      const { _id } = req.params
+      if (req.user.isAdmin) {
+        const { _id } = req.params
 
-      const payloadWithTag = await tagService.hardDeleteTag(
-        fastify,
-        req.requestParams,
-        _id,
-      )
+        const payloadWithTag = await tagService.hardDeleteTag(
+          fastify,
+          req.requestParams,
+          _id,
+        )
 
-      return payloadWithTag
+        return payloadWithTag
+      } else {
+        throw new ForbiddenError(
+          "Only admins can hard delete this core datatype",
+        )
+      }
     } catch (error: any) {
       fastify.log.error(error.message)
       return reply.internalServerError(error.message)

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)
 
@@ -318,7 +320,10 @@ export class TagService {
     id: string,
   ): Promise<TagType> {
     try {
-      const tag = await this.tagModel.findOne({ _id: id, isDeleted: true })
+      const tag = await this.tagModel.findOne({
+        _id: id,
+        isDeleted: true,
+      })
 
       if (!tag) {
         throw new Error(
@@ -326,9 +331,13 @@ export class TagService {
         )
       }
 
-      await this.tagModel.deleteOne({ _id: id })
+      const res = await tag.deleteOne()
 
-      return tag.toObject ? tag.toObject() : tag
+      if (res?.deletedCount === 1) {
+        return tag.toObject ? tag.toObject() : tag
+      }
+
+      throw new Error(`Deletion of Tag with ID ${id} was not successful.`)
     } catch (error: any) {
       fastify.log.error(error.message)
       throw error

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

@@ -5,13 +5,17 @@ import patch from "./route.user.patch"
 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))
   await fastify.patch(
     "/user/last-project/:projectId",
     patchLastProject(fastify),

package/services/backend/src/corePlugins/raclette__core/backend/datatypes/user/routes/route.user.hardDelete.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 payloadWithUser = await userService.hardDeleteUser(
+          fastify,
+          req.requestParams,
+          _id,
+        )
+
+        return payloadWithUser
+      } else {
+        throw new ForbiddenError(
+          "Only admins can hard delete this core datatype",
+        )
+      }
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataHardDeleted",
+      broadcastChannels: ["userHardDeleted"],
+    },
+    schema: {
+      summary: "Permanently delete a user by id",
+      description: "Hard delete a user",
+      tags: ["core/user"],
+      params: ParamsSchema,
+    },
+  }
+}

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)
 
@@ -287,6 +288,38 @@ export class UserService {
     return payload
   }
 
+  /**
+   * Core function to hard delete an interaction link (returns raw data)
+   */
+  async _hardDeleteUser(
+    fastify: PluginFastifyInstance,
+    id: string,
+  ): Promise<UserType> {
+    try {
+      const user = await this.userModel.findOne({
+        _id: id,
+        isDeleted: true,
+      })
+
+      if (!user) {
+        throw new Error(
+          `User with ID ${id} not found or not marked for deletion`,
+        )
+      }
+
+      const res = await user.deleteOne()
+
+      if (res?.deletedCount === 1) {
+        return user.toObject ? user.toObject() : user
+      }
+
+      throw new Error(`Deletion of User with ID ${id} was not successful.`)
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
   /**
    * Core function to update user's last accessed project (returns raw data)
    */

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 {
@@ -164,11 +165,11 @@ const cacheOperations = {
   },
 }
 
-const finishRemoteQuery = (actionIdentifier, result, params, options) => {
+const finishRemoteQuery = (actionIdentifier, result = {}, params, options) => {
   const { actionId, cacheKey } = actionIdentifier
   log.api("finishRemoteQuery", { actionId, params, result })
 
-  if (!result.data) {
+  if (!result?.data) {
     return
   }
   let resultBody = structuredClone(result.data.body)
@@ -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,20 +237,8 @@ const handleRemoteRequest = async (
   try {
     const response =
       method === "GET"
-        ? await $api.axios.get(target, config).catch((e) => {
-            $eventbus.emit("ui/addToSnackbar", {
-              message: e.response.data.message,
-              color: "error",
-            })
-            throw e
-          })
-        : await $api.axios.post(target, params, config).catch((e) => {
-            $eventbus.emit("ui/addToSnackbar", {
-              message: e.response.data.message,
-              color: "error",
-            })
-            throw e
-          })
+        ? await $api.axios.get(target, config).catch(handleErrors)
+        : await $api.axios.post(target, params, config).catch(handleErrors)
 
     return {
       response,
@@ -258,7 +246,7 @@ const handleRemoteRequest = async (
     }
   } catch (e) {
     if (e.name === "AbortError" || e.name === "CanceledError") {
-      log.api(`${method} request was cancelled for actionId:`, actionIdentifier)
+      log.api(`${method} request was canceled for actionId:`, actionIdentifier)
       throw e
     }
 
@@ -442,7 +430,7 @@ const executeRoute = async (actionIdentifier, validTarget, params, options) => {
 
         if (error.name === "AbortError" || error.name === "CanceledError") {
           log.api(
-            "HTTP request was cancelled for actionId:",
+            "HTTP request was canceled for actionId:",
             actionIdentifier.actionId,
           )
           throw error

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

@@ -162,7 +162,7 @@ const handler = {
       requestId,
       data,
     })
-    const deleted = data.deleted || []
+    const deleted = data.items || []
     $store.dispatch({ type: "data/hardDelete", payload: deleted })
     if (notify) {
       userNotifier.dataDelete(isOwnRequest, isSystemAction, deleted)

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

@@ -1,6 +1,10 @@
 import log from "@racletteCore/lib/logger"
-import { $api, $store, $eventbus } from "@racletteCore"
-import { removeCacheAttributes, capitalize } from "@racletteCore/lib/dataHelper"
+import { $api, $store } from "@racletteCore"
+import {
+  removeCacheAttributes,
+  capitalize,
+  handleErrors,
+} from "@racletteCore/lib/dataHelper"
 import handleServerItem from "./responseTypeHandler"
 import { handleOperationTarget } from "@racletteCore/setup/plugin-system"
 
@@ -25,16 +29,7 @@ const createAxiosConfig = (appRequestCode, pluginItemRequestConfig) => {
   }
   return config
 }
-const reportError = (error) => {
-  const message = error?.response?.data?.message || false
 
-  $eventbus.emit("ui/addToSnackbar", {
-    message,
-    i18n: message ? false : "core.error.noConnectionToServer",
-    color: "error",
-  })
-  throw error
-}
 const storeActions = {
   dataMove: (actionId, payload) => {
     const newParent = payload.item.newParent
@@ -128,7 +123,7 @@ const writeData = async (actionId, operationDefinition, item, options) => {
           response: res,
         }
       })
-      .catch((e) => reportError(e))
+      .catch(handleErrors)
   } else {
     return await getAxiosPromise(
       operationDefinition.method,
@@ -142,7 +137,7 @@ const writeData = async (actionId, operationDefinition, item, options) => {
           result: handleServerItem(res.data, notify, true),
         }
       })
-      .catch((e) => reportError(e))
+      .catch(handleErrors)
   }
 }
 

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

@@ -7,6 +7,20 @@ import log from "@racletteCore/lib/logger"
 import { $eventbus } from "@racletteCore/main"
 import { $store } from "@racletteCore/main"
 
+const handleErrors = (e) => {
+  $eventbus.emit("backend/error", e)
+  log.api("handleErrors", e)
+  // TODO expand error handling for other transports
+  if (e.name === "AxiosError") {
+    const errorResponse = e.response || {}
+    $eventbus.emit("ui/addToSnackbar", {
+      message: errorResponse.data?.message || "error",
+      color: "error",
+    })
+    throw e
+  }
+  return {}
+}
 const hasOwnProperty = (obj, prop) =>
   Object.prototype.hasOwnProperty.call(obj, prop)
 const fileExists = async (path: string): Promise<boolean> => {
@@ -468,4 +482,5 @@ export {
   getCookie,
   hasOwnProperty,
   fileExists,
+  handleErrors,
 }

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

@@ -6,19 +6,9 @@
  * change of state, others represent a request addressed to a specific actor,
  * e.g. 'asks the http client to get x'
  *
- * @TODO
- * - find clear naming policy
- * - use speaking event names, even though they are longer
- * - distinguish between a information and request (e.g. store_dispatch is a request to the store)
  */
-const legacyEventWhitelist = [
-  "socket_joinRoom",
-  "socket_leaveRoom",
-  "socket_dataUpdated",
-  "ui_setupProject",
-  "ui_addToSnackBar",
-]
-const eventWhitelist = legacyEventWhitelist.concat([
+
+const eventWhitelist = [
   "forms/init",
   "forms/validate",
   "widgets/reset/workingState",
@@ -27,7 +17,8 @@ const eventWhitelist = legacyEventWhitelist.concat([
   "socket/data/update",
   "socket/join/room",
   "socket/leave/room",
-])
+  "backend/error",
+]
 const eventWildcards = [
   "query_deleted",
   "store_actionResolved",

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

@@ -129,7 +129,7 @@ const userConfigUpdate = (isAnswerToOwnRequest, isSystemAction, items) =>
     color: "info",
   })
 
-const dataDelete = (isAnswerToOwnRequest, isSystemAction, deletedItems) =>
+const dataDelete = (isAnswerToOwnRequest, isSystemAction, deletedItems) => {
   deletedItems.forEach((item) => {
     if (isAnswerToOwnRequest) {
       $eventbus.emit("ui/addToSnackbar", {
@@ -153,6 +153,7 @@ const dataDelete = (isAnswerToOwnRequest, isSystemAction, deletedItems) =>
       })
     }
   })
+}
 
 const dataMove = (isAnswerToOwnRequest, isSystemAction, items) => {
   items.forEach((item) => {

package/services/frontend/src/core/main.ts

@@ -159,12 +159,18 @@ const generateLoginCallback =
           success: true,
           token: token,
           redirect: () => {
+            const params = new URLSearchParams(window.location.search)
+            const redirect = params.get("redirect") || ""
             // If we're in the same origin, we keep the history
             if (
               _callbackUrl.startsWith(window.location.origin) ||
               _callbackUrl.startsWith("/")
             ) {
-              window.location.href = _callbackUrl
+              if (redirect.length && redirect.startsWith("/:")) {
+                window.location.href = _callbackUrl + redirect
+              } else {
+                window.location.reload()
+              }
             } else {
               // Otherwise do a full page reload to the callback URL
               window.location.replace(_callbackUrl)

package/services/frontend/src/orchestrator/LoginApp.vue

@@ -52,7 +52,6 @@ const onSubmitLogin = async (loginPayload: {
 }) => {
   if (props.loginMethod) {
     const { success, message, redirect } = await props.loginMethod(loginPayload)
-
     if (success) {
       redirect?.()
     } else if (message) {