@raclettejs/core 0.1.17 → 0.1.19

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

@@ -4,13 +4,17 @@ import getAll from "./route.tag.getAll"
 import hardDelete from "./route.tag.hardDelete"
 import patch from "./route.tag.patch"
 import post from "./route.tag.post"
+import postBulk from "./route.tag.post.bulk"
 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.post("/tag/bulk", postBulk(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.post.bulk.ts

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

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

@@ -8,7 +8,9 @@ import type { PluginFastifyInstance } from "types"
 import { v4 as uuidv4, validate } from "uuid"
 import { createTagPayload } from "./helpers/payload"
 import type { Model } from "mongoose"
-
+export type TagBody = Partial<Omit<TagType, "_id">> & {
+  _id?: string
+}
 export class TagService {
   private tagModel: Model<TagType>
 
@@ -131,6 +133,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)
 
@@ -367,6 +371,75 @@ export class TagService {
 
     fastify.emit("tagHardDeleted", payload)
 
+    return payload
+  }
+  /**
+   * Core function to create multiple tags (returns raw data)
+   */
+  async _createTags(
+    fastify: PluginFastifyInstance,
+    tagBodies: TagBody[],
+    userId: string,
+  ): Promise<TagType[]> {
+    try {
+      const tagsToCreate: TagBody[] = []
+
+      // Validate and prepare all tags
+      for (const tagBody of tagBodies) {
+        if (tagBody._id) {
+          const uuidValid = validate(tagBody._id)
+
+          if (!uuidValid) {
+            throw new Error(`Invalid ID - not a valid uuid v4: ${tagBody._id}`)
+          }
+
+          const duplicate = await this.tagModel.findOne({
+            _id: tagBody._id,
+          })
+
+          if (duplicate) {
+            throw new Error(
+              `An entry with this id already exists: ${tagBody._id}`,
+            )
+          }
+        } else {
+          tagBody._id = uuidv4()
+        }
+
+        tagsToCreate.push({
+          ...tagBody,
+          author: userId,
+          lastEditor: userId,
+        })
+      }
+
+      // Bulk insert
+      const tags = await this.tagModel.insertMany(tagsToCreate)
+
+      fastify.log.info(`[API] Created ${tags.length} tags in bulk`)
+
+      return tags.map((comp) => (comp.toObject ? comp.toObject() : comp))
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      throw error
+    }
+  }
+
+  /**
+   * Create multiple tags with payload wrapping and event emission
+   */
+  async createTags(
+    fastify: PluginFastifyInstance,
+    requestData: FrontendPayloadRequestData,
+    tagBodies: TagBody[],
+    userId: string,
+  ): Promise<FrontendPayload<TagType[]>> {
+    const tags = await this._createTags(fastify, tagBodies, userId)
+
+    const payload = await createTagPayload(fastify, tags, requestData)
+
+    fastify.emit("tagsCreated", payload)
+
     return payload
   }
 }

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/dataApi.ts

@@ -29,7 +29,16 @@ const $writeDataApi = (
       const _executeParams = clone(executeParams)
       errorSubject$.next(null)
       responseSubject$.next({})
-      const queryParams = mergeDeepRight(_params, _executeParams)
+      let queryParams
+      if (Array.isArray(_executeParams)) {
+        if (Array.isArray(_params)) {
+          queryParams = _params.concat(_executeParams)
+        }
+        queryParams = _executeParams
+      } else {
+        queryParams = mergeDeepRight(_params, _executeParams)
+      }
+
       if (options.responseType === "stream") {
         return writeData(actionId, operationDefinition, queryParams, options)
       }

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,

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,
 }