@raclettejs/core 0.1.22 → 0.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raclettejs/core",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "racletteJS core package",
   "repository": "https://gitlab.com/raclettejs/core",
   "author": "Pacifico Digital Explorations GmbH <info@raclettejs.com>",
@@ -59,40 +59,42 @@
   },
   "config": {},
   "dependencies": {
-    "@inquirer/prompts": "8.2.0",
+    "@inquirer/prompts": "8.3.2",
     "@types/mustache": "4.2.6",
     "chalk": "5.6.2",
-    "chokidar": "3.6.0",
+    "chokidar": "5.0.0",
     "cli-highlight": "2.1.11",
-    "commander": "14.0.1",
-    "dotenv": "17.2.2",
-    "esbuild": "0.25.9",
-    "fs-extra": "11.3.2",
-    "globby": "14.1.0",
-    "js-yaml": "4.1.0",
+    "commander": "14.0.3",
+    "dotenv": "17.3.1",
+    "esbuild": "0.27.4",
+    "fs-extra": "11.3.4",
+    "globby": "16.1.1",
+    "js-yaml": "4.1.1",
     "mustache": "4.2.0",
-    "ramda": "0.31.3",
+    "ramda": "0.32.0",
     "tsc-alias": "1.8.16"
   },
   "devDependencies": {
+    "@emnapi/core": "1.9.2",
+    "@emnapi/runtime": "1.9.2",
     "@eslint/js": "9.35.0",
-    "@raclettejs/types": "^0.1.22",
+    "@raclettejs/types": "^0.1.24",
     "@types/fs-extra": "11.0.4",
     "@types/js-yaml": "4.0.9",
-    "@types/node": "24.5.1",
+    "@types/node": "25.5.0",
     "@types/ramda": "0.31.1",
     "eslint": "9.35.0",
-    "eslint-config-prettier": "10.1.8",
-    "eslint-flat-config-utils": "2.1.1",
+    "eslint-config-prettier": "9.1.2",
+    "eslint-flat-config-utils": "3.0.2",
     "eslint-plugin-import": "2.32.0",
-    "eslint-plugin-prefer-arrow-functions": "3.8.1",
-    "eslint-plugin-prettier": "5.5.4",
-    "eslint-plugin-vue": "10.4.0",
-    "globals": "16.4.0",
+    "eslint-plugin-prefer-arrow-functions": "3.9.1",
+    "eslint-plugin-prettier": "5.5.5",
+    "eslint-plugin-vue": "9.33.0",
+    "globals": "17.4.0",
     "husky": "9.1.7",
-    "prettier": "3.6.2",
-    "typescript": "5.9.2",
-    "typescript-eslint": "8.44.0",
-    "vue-eslint-parser": "10.2.0"
+    "prettier": "3.8.1",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.57.1",
+    "vue-eslint-parser": "9.4.3"
   }
 }

package/services/backend/package.json

@@ -16,6 +16,7 @@
     "build:assets:src": "copyfiles -u 1 'src/**/*.{json,js,yml,yaml,env*}' dist",
     "build:assets:root": "copyfiles -u 0 'raclette.config.js' dist",
     "build:assets": "npm run build:assets:src && npm run build:assets:root",
+    "lint": "eslint .",
     "migrate:create": "npx migrate-mongo create -f './mongo-migrations/migrate-mongo-config.js'",
     "migrate:up": "migrate-mongo up -f './mongo-migrations/migrate-mongo-config.js'",
     "migrate:down": "migrate-mongo down -f './mongo-migrations/migrate-mongo-config.js'",
@@ -24,28 +25,29 @@
     "typecheck:watch": "tsc --noEmit --watch"
   },
   "dependencies": {
-    "@fastify/cors": "11.1.0",
+    "@fastify/cors": "11.2.0",
     "@fastify/jwt": "10.0.0",
     "@fastify/rate-limit": "10.3.0",
     "@fastify/schedule": "6.0.0",
-    "@fastify/sensible": "6.0.3",
-    "@sinclair/typebox": "0.34.41",
+    "@fastify/sensible": "6.0.4",
+    "@sinclair/typebox": "0.34.48",
     "@types/vary": "1.1.3",
-    "axios": "1.13.2",
+    "axios": "1.13.6",
     "bcrypt": "6.0.0",
     "copyfiles": "2.4.1",
-    "fastify": "5.6.0",
+    "fastify": "5.8.2",
     "fastify-custom-healthcheck": "4.0.0",
-    "glob": "11.0.3",
+    "fs-extra": "11.3.4",
+    "glob": "13.0.6",
     "iovalkey": "0.3.3",
-    "migrate-mongo": "12.1.3",
-    "mongodb": "^6.20.0",
-    "mongoose": "8.18.1",
-    "nanoid": "5.1.5",
-    "pino": "9.9.5",
-    "pino-pretty": "13.1.1",
-    "ramda": "0.31.3",
-    "socket.io": "4.8.1",
+    "migrate-mongo": "14.0.7",
+    "mongodb": "6.21.0",
+    "mongoose": "8.23.0",
+    "nanoid": "5.1.7",
+    "pino": "10.3.1",
+    "pino-pretty": "13.1.3",
+    "ramda": "0.32.0",
+    "socket.io": "4.8.3",
     "toad-scheduler": "3.1.0",
     "tsc-alias": "1.8.16",
     "uuid": "13.0.0"
@@ -58,9 +60,9 @@
     "@types/uuid": "11.0.0",
     "eslint": "9.35.0",
     "eslint-plugin-import": "2.32.0",
-    "eslint-plugin-prefer-arrow-functions": "3.8.1",
-    "tsx": "4.20.5",
-    "typescript": "5.9.2",
-    "typescript-eslint": "8.44.0"
+    "eslint-plugin-prefer-arrow-functions": "3.9.1",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.57.1"
   }
-}
+}

package/services/backend/src/core/contracting/contractRegistrar.ts

@@ -12,7 +12,7 @@ export const registerPluginContract = (
   contract: PluginContract,
 ): void => {
   if (contracts[pluginKey]) {
-    throw new Error(`Plugin contract for "${pluginKey}" is already registered`)
+    throw new Error(`Plugin contract for "${pluginKey}" is already registered. Make sure that each plugin is calling fastify.generatePluginContract only once! Multiple calls are not allowed.`)
   }
 
   contracts[pluginKey] = contract

package/services/backend/src/core/pluginSystem/configGenerator/generatorTypes.ts

@@ -13,6 +13,7 @@ export type PluginRegistration = {
   author: string
   pluginKey: string
   pluginPath: string
+  frontendPath: string
   routePrefix: string
   entityMapping?: Record<string, string>
   customConfig?: {

package/services/backend/src/core/pluginSystem/configGenerator/index.ts

@@ -42,6 +42,7 @@ class FrontendConfigRegistry {
       author: pluginData.author,
       pluginKey: pluginData.key,
       pluginPath: pluginData.absolutePath,
+      frontendPath: pluginData.frontendAbsolutePath,
       routePrefix: pluginData.routePrefix,
       entityMapping: options?.entityMapping || {},
       customConfig: options?.customConfig,
@@ -451,8 +452,7 @@ const writePluginConfigFile = async (
 
   const configContent = generatePluginConfigFile(dataTypes, registration)
   const outputPath = path.join(
-    registration.pluginPath,
-    "frontend",
+    registration.frontendPath,
     "generated-config.ts",
   )
 

package/services/backend/src/core/pluginSystem/pluginLoader.ts

@@ -30,6 +30,7 @@ interface PluginInfo {
   pluginName: string
   modulePath: string
   pluginPath: string
+  frontendPath: string
   type: PluginType
   metadata: PluginMetadata
 }
@@ -75,6 +76,74 @@ const logPluginError = (
   fastify.log.debug(`${createLogPrefix(type)} ${identifier}: ERROR - ${error}`)
 }
 
+const normalizeRelativeDir = (dir?: string): string | undefined =>
+  dir?.replace(/^\.\//, "")
+
+const resolveExistingServicePath = async (
+  pluginPath: string,
+  candidates: string[],
+): Promise<{ relativePath: string; absolutePath: string } | undefined> => {
+  for (const candidatePath of candidates) {
+    const normalizedCandidatePath = normalizeRelativeDir(candidatePath)
+    if (!normalizedCandidatePath) continue
+
+    const candidateAbsolutePath = path.join(pluginPath, normalizedCandidatePath)
+    try {
+      const stat = await fs.promises.stat(candidateAbsolutePath)
+      if (stat.isDirectory()) {
+        return {
+          relativePath: normalizedCandidatePath,
+          absolutePath: candidateAbsolutePath,
+        }
+      }
+    } catch {
+      // path missing or not accessible
+    }
+  }
+}
+
+const resolveBackendPath = async (
+  pluginPath: string,
+  metadata: PluginMetadata,
+): Promise<{ relativePath: string; absolutePath: string } | undefined> => {
+  const backendPathCandidates = getBackendPathCandidates(metadata)
+
+  return resolveExistingServicePath(pluginPath, backendPathCandidates)
+}
+
+const getBackendPathCandidates = (metadata: PluginMetadata): string[] => {
+  const explicitBackendDir = normalizeRelativeDir(metadata.backendDir)
+  if (explicitBackendDir) {
+    return [explicitBackendDir]
+  }
+
+  return ["backend", "src/backend"]
+}
+
+const resolveFrontendPath = async (
+  pluginPath: string,
+  metadata: PluginMetadata,
+  backendRelativePath?: string,
+): Promise<string> => {
+  const explicitFrontendDir = normalizeRelativeDir(metadata.frontendDir)
+  if (explicitFrontendDir) {
+    return path.join(pluginPath, explicitFrontendDir)
+  }
+
+  const resolvedFrontendPath = await resolveExistingServicePath(pluginPath, [
+    "frontend",
+    "src/frontend",
+  ])
+  if (resolvedFrontendPath) {
+    return resolvedFrontendPath.absolutePath
+  }
+
+  // Fall back to src/frontend when backend is under src, otherwise frontend.
+  const fallbackRelativePath =
+    backendRelativePath?.startsWith("src/") ? "src/frontend" : "frontend"
+  return path.join(pluginPath, fallbackRelativePath)
+}
+
 /**
  * Get app plugin paths for current environment
  */
@@ -254,16 +323,18 @@ const collectLocalPluginsFromPath = async (
         continue
       }
 
-      // Get backend path from metadata or use default
-      const backendRelativePath = metadata.backendDir || "backend"
-      const backendPath = path.join(pluginPath, backendRelativePath)
+      // Get backend path from metadata or try supported defaults.
+      const resolvedBackendPath = await resolveBackendPath(pluginPath, metadata)
+      const backendRelativePath = resolvedBackendPath?.relativePath
+      const backendPath = resolvedBackendPath?.absolutePath
 
-      if (!fs.existsSync(backendPath)) {
+      if (!backendRelativePath || !backendPath) {
+        const backendPathCandidates = getBackendPathCandidates(metadata)
         logPluginSkipped(
           fastify,
           pluginType,
           pluginIdentifier,
-          `backend directory not found: ${backendRelativePath}`,
+          `backend directory not found: ${backendPathCandidates.join(" or ")}`,
         )
         if (metadata.backendDir) {
           // we only cancel when the dir was explicitly set
@@ -277,24 +348,6 @@ const collectLocalPluginsFromPath = async (
         continue
       }
 
-      if (!fs.statSync(backendPath).isDirectory()) {
-        logPluginSkipped(
-          fastify,
-          pluginType,
-          pluginIdentifier,
-          `backend path is not a directory: ${backendRelativePath}`,
-        )
-        if (metadata.backendDir) {
-          handlePluginError(
-            fastify,
-            `Server directory not found for plugin: ${configPath}`,
-            pluginType,
-            errorFlags,
-          )
-        }
-        continue
-      }
-
       // Find the main module file
       const modulePath = getFilePathWithExtension(backendPath, "index")
       if (!modulePath) {
@@ -315,12 +368,18 @@ const collectLocalPluginsFromPath = async (
 
       const author = slugify(metadata.author)
       const pluginName = slugify(metadata.name)
+      const frontendPath = await resolveFrontendPath(
+        pluginPath,
+        metadata,
+        backendRelativePath,
+      )
 
       plugins.push({
         author,
         pluginName,
         modulePath,
         pluginPath,
+        frontendPath,
         type: pluginType,
         metadata,
       })
@@ -462,32 +521,21 @@ const collectNpmPlugins = async (
         continue
       }
 
-      // Get backend path from metadata or use default
-      const backendRelativePath = pluginMetadata.backendDir || "src/backend"
-      const backendPath = path.join(pluginPath, backendRelativePath)
-
-      if (!fs.existsSync(backendPath)) {
-        logPluginSkipped(
-          fastify,
-          PluginType.NPM,
-          pluginPackage,
-          `backend directory not found: ${backendRelativePath}`,
-        )
-        handlePluginError(
-          fastify,
-          `Server directory not found for npm plugin: ${pluginPackage}`,
-          PluginType.NPM,
-          errorFlags,
-        )
-        continue
-      }
+      // Get backend path from metadata or try supported defaults.
+      const resolvedBackendPath = await resolveBackendPath(
+        pluginPath,
+        pluginMetadata,
+      )
+      const backendRelativePath = resolvedBackendPath?.relativePath
+      const backendPath = resolvedBackendPath?.absolutePath
 
-      if (!fs.statSync(backendPath).isDirectory()) {
+      if (!backendRelativePath || !backendPath) {
+        const backendPathCandidates = getBackendPathCandidates(pluginMetadata)
         logPluginSkipped(
           fastify,
           PluginType.NPM,
           pluginPackage,
-          `backend path is not a directory: ${backendRelativePath}`,
+          `backend directory not found: ${backendPathCandidates.join(" or ")}`,
         )
         handlePluginError(
           fastify,
@@ -518,12 +566,18 @@ const collectNpmPlugins = async (
 
       const author = slugify(pluginMetadata.author)
       const pluginName = slugify(pluginMetadata.name)
+      const frontendPath = await resolveFrontendPath(
+        pluginPath,
+        pluginMetadata,
+        backendRelativePath,
+      )
 
       plugins.push({
         author,
         pluginName,
         modulePath,
         pluginPath,
+        frontendPath,
         type: PluginType.NPM,
         metadata: pluginMetadata,
       })
@@ -704,6 +758,7 @@ const registerCollectedPlugins = async (
         collectionPrefix,
         routePrefix,
         absolutePath: plugin.pluginPath,
+        frontendAbsolutePath: plugin.frontendPath,
       }
 
       // Dynamically import the plugin module

package/services/backend/src/core/pluginSystem/pluginTypes.ts

@@ -25,6 +25,7 @@ export type PluginOptions = {
   pluginName: string
   author: string
   absolutePath: string
+  frontendAbsolutePath: string
   type: PluginType
   collectionPrefix: string
   routePrefix: string

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

@@ -2,6 +2,7 @@ import { PluginFastifyInstance } from "types"
 import get from "./route.user.get"
 import getAll from "./route.user.getAll"
 import patch from "./route.user.patch"
+import patchOwn from "./route.user.patchOwn"
 import patchLastProject from "./route.user.patchLastProject"
 import post from "./route.user.post"
 import remove from "./route.user.remove"
@@ -12,6 +13,7 @@ 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/self", patchOwn(fastify))
   await fastify.patch("/user/:_id/restore", restore(fastify))
   await fastify.post("/user", post(fastify))
   await fastify.delete("/user/:_id", remove(fastify))

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

@@ -0,0 +1,68 @@
+import type { Static } from "@sinclair/typebox"
+import type { FastifyReply, FastifyRequest } from "fastify"
+import type { PluginFastifyInstance } from "types"
+import { Type } from "@sinclair/typebox"
+import { UnauthorizedError } from "@/utils/errors"
+import { userUpdateSchema } from "../user.schema"
+
+type UserBody = Static<typeof userUpdateSchema>
+
+export default (fastify: PluginFastifyInstance) => {
+  const userService = fastify.custom.userService
+
+  const handler = async (
+    req: FastifyRequest<{
+      Params: {}
+      Body: UserBody
+    }>,
+    reply: FastifyReply,
+  ) => {
+    try {
+      if (req.user._id !== req.body._id) {
+        throw new UnauthorizedError("not your user")
+      }
+      // only let the user update non vital fields
+      const updateObject = {}
+      if (req.body?.email?.length) {
+        updateObject.email = req.body.email
+        // TODO Creation of the field should be happening in the user.model pre save hook
+        updateObject.email_verified = false
+      }
+      if (req.body?.firstname?.length) {
+        updateObject.firstname = req.body.firstname
+      }
+      if (req.body?.lastname?.length) {
+        updateObject.lastname = req.body.lastname
+      }
+      if (req.body?.password?.length) {
+        updateObject.password = req.body.password
+      }
+      const payloadWithUser = await userService.updateUser(
+        fastify,
+        req.requestParams,
+        req.user._id,
+        updateObject,
+      )
+
+      return payloadWithUser
+    } catch (error: any) {
+      fastify.log.error(error.message)
+      return reply.internalServerError(error.message)
+    }
+  }
+
+  return {
+    handler,
+    onRequest: [fastify.authenticate],
+    config: {
+      type: "dataUpdate",
+      broadcastChannels: ["userUpdated"],
+    },
+    schema: {
+      summary: "Update a user",
+      description: "Update specific fields of a user profile",
+      tags: ["core/user"],
+      body: userUpdateSchema,
+    },
+  }
+}

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

@@ -2,7 +2,7 @@ import type { IUserMethods, UserDoc } from "./user.schema"
 import bcrypt from "bcrypt"
 import { v4 as uuidv4 } from "uuid"
 import { randomIdGenerator } from "@/helpers"
-import { PluginFastifyInstance } from "types"
+import type { PluginFastifyInstance } from "types"
 import mongoose from "mongoose"
 
 export const MODEL_BASENAME = "user"

package/services/backend/tsconfig.json

@@ -17,6 +17,7 @@
       "@m/*": ["./src/modules/*"],
       "@shared/*": ["./src/shared/*"],
       "@/*": ["./src/*"],
+      "@app/*": ["./app/*"],
       "@raclettejs/core/backend": ["./src/index.ts", "./src"],
       "@raclettejs/core/backend/*": ["./src/*"],
       "@raclettejs/core": ["../..", "/app/types"]